认识达内从这里开始

char c='\u4e00' //汉字开始

char c='\u9fa5'//汉字结束

java 正则 正则表达式： java.util.regex.Pattern

[] 匹配的一个字符

[^a] 一个非a的字符

[^abcd]一个非a，b，c，d的字符

[A-Z] 一个 A-Z 的字符

[a-z] 一个a-z的字符

[0-9] 一个0-9 的字符

[a-z&&[^bc]]一个a-z的字符 而且不能是bc

. 任意一个字符

\d 任意一个数字

\w[a-zA-Z0-9_]

\s空白字符 [\y\n\xOB\f\r]

\D非 \d

\W非 \w

\S非 \s

量词

[0-9]? 0 或者1

[0-9]* 0 到无限

[0-9]+ 最少一个

[0-9]{6} 必须6个

[0-9]{6,}最少6个

[0-9]{0,6}最多6个

[0-9]{6,9}6-18位

(\+86) +86 这个整体

位置限定符

^ 第一个字符

$ 最后一个字符

分组

()

特殊字符转义

\

^[\w]+@[\w]+(\.[a-zA-Z0-9]+)+$

但是 java中的String 中的matches 中的匹配时全匹配 也就是^ $ 你加不加 java 都帮你加上了

| 或的意思

(0086|\+86) 0086 或者 +86

Object 是所有类的父类

Object 东西

toString()方法

1)返回对象文本描述

2)被很多API默认调用

3)建议重写toString方法，对象的文本描述

4)建议自定义的每一类增加toString()方法

equals 方法： 比较两个对象的内容是否一样

instanceof

instance of 的实例

== 比较变量的值，引用变量的值是地址值 比的是对象的地址(引用类型变量 指向的地址)

也就是比较的是否是同一个对象

package se.day001;

/**

* 斗地主

* @author 煊

*

*/

public class Card {

/** 花色*/

private int suit;

/** 点数*/

private int rank;

public static final int THREE=0;

public static final int FOUR=1;

public static final int FIVE=2;

public static final int SIX=3;

public static final int SEVEN=4;

public static final int EIGHT=5;

public static final int NINE=6;

public static final int TEN=7;

public static final int JACK=8;

public static final int QUEEN=9;

public static final int KING=10;

/**

* A

*/

public static final int ACE=11;

/**

* 2

*/

public static final int DEUCE=12;

/**

* 小王

*/

public static final int BLACK=13;

/**

* 大王

*/

public static final int COLOR=14;

/**

* 方块

*/

public static final int DIAMOND = 0;

/**

* 梅花

*/

public static final int CLUB = 1;

/**

* 红桃

*/

public static final int HRART = 2;

/**

* 黑桃

*/

public static final int SPADE = 3;

/**

* 王

*/

public static final int JOKER = 4;

public Card(int suit,int rank){

this.suit = suit;

this.rank = rank;

}

public int getSuit(){

return suit;

}

public int getRank(){

return rank;

}

public void setSuit(int suit){

this.suit = suit;

}

public void setRank(int rank){

this.rank = rank;

}

private static String[] suitName = {"方块","梅花","红桃","黑桃",""};

private static String[] rankName = {"3","4","5","6","7","8","9","10","J","Q","K","A","2","小王","大王"};

@Override

public String toString(){

return "点数:"+rankName[rank]+";花色:"+suitName[suit];

}

@Override

public int hashCode() {

final int prime = 31;

int result = 1;

result = prime * result + rank;

result = prime * result + suit;

return result;

}

@Override

public boolean equals(Object obj) {

if (this == obj)

return true;

if (obj == null)

return false;

if(obj instanceof Card){

Card other = (Card)obj;

return this.rank ==other.rank && this.suit == other.suit;

}

return false;

}

}

package se.day001;

/**

* 建议重写toString方法，对象的文本描述

* @author 煊

*

*/

public class Dmeo01 {

public static void main(String[] args){

Card ace = new Card(Card.SPADE,Card.ACE);

String whatIsIt = ace.toString();

System.out.println(whatIsIt);

Card c1 = new Card(Card.DEUCE,Card.TEN);

Card c2 = new Card(Card.DEUCE,Card.TEN);

Card c3 = c1;

System.out.println(c1==c2);

System.out.println(c1==c3);

System.out.println(c1.equals(c2));

System.out.println(c1.equals(c3));

}

}

package se.day001;

public class Demo02 {

public static void main(String[] args){

Object o1 = new Card(Card.DIAMOND,Card.THREE);

Object o2 = "方块3";

System.out.println(IsCard(o1));

System.out.println(IsCard(o2));

}

public static boolean IsCard(Object o){

if(o ==null){

return false;

}else{

return (o instanceof Card);

}

}

}

String 类的特点

字符串是字符数组组成的

字符串 对象 是不可改变的，字符串引用可以重新赋值

为了提高性能，静态字符串(字面量/常量/常量连接的结果)在静态池中创建，尽量使用同一个对象，重用静态字符串

package se.day001;

import java.util.Arrays;

/**

* 实现 字符数组内容转为小写

* 实现 字符数组内容转为大写

* @author 煊

*

*/

public class Demo03 {

public static void main(String[] args){

char[] chs = {'I','l','o','v','e','u'};

char[] chs2 = Arrays.copyOf(chs, chs.length);

for(int i = 0;i

if(chs2[i]>'A' && chs2[i]<'Z'){

chs2[i]=(char)(chs2[i]-('A'-'a'));

}

}

System.out.println(chs);

System.out.println(chs2);

String str = "I love u";

System.out.println(str);

System.out.println(str.toLowerCase());

System.out.println(str.toUpperCase());

}

}

package se.day02;

/**

* 正则

* @author zongx

*

*/

public class StringDemo {

public static void main(String[] args){

if(Test.email("81240805@qq.com")){

System.out.println("yes");

}else{

System.out.println("no");

}

if(Test.ID("321321199909191099")){

System.out.println("yes");

}else{

System.out.println("no");

}

}

}

class Test{

public static boolean email(String email){

String regex = "[\\w]+@[\\da-zA-Z0]+(\\.[\\da-zA-Z]+)+";

//String mail = "81240805@qq.com";

return email.matches(regex);//全匹配

}

public static boolean ID(String ID){

String regex ="[1-9]\\d{14}(\\d{2}[\\dxX])?";

return ID.matches(regex);

}

}

package se.day02;

/**

* 将字符串 中满足正则表达式的部分替换为给定内容

* @author 煊

*

*/

public class StringDemo3 {

public static void main(String[] args){

String str ="asdfhaj lh8349 38 512 jlkg0erg 03u0 24 ";

str = str.replaceAll("\\d+", "AA");

System.out.println(str);

String regex ="(sb|wqnmlgb|cnm|djb)";

String msg = "sb,你个djb";

String message = msg.replaceAll(regex, "****");

System.out.println(message);

}

}

Java 的字符串连接的过程是利用StringBuilder 实现的

建议在大量字符串计算的时候利用StringBuilder

String

StringBuilder

api方法是对其那内部char[] 内容进行 增删改查方法

package se.day001;

public class Demo05 {

public static void main(String[] args){

StringBuilder buf = new StringBuilder();

System.out.println(buf.append("123"));//增

System.out.println(buf.delete(0, 1));//删

System.out.println(buf.insert(0,"4"));//插入

System.out.println(buf.indexOf("4"));//查

System.out.println(buf.append("123"));

System.out.println(buf.replace(1,2, "22"));//替换

System.out.println(buf.reverse());//反转

}

}

StringBuffer

package se.day001;

public class Demo06 {

public static void main(String[] args){

StringBuffer buf = new StringBuffer();

System.out.println(buf.append("123"));//增

System.out.println(buf.delete(0, 1));//删

System.out.println(buf.insert(0,"4"));//插入

System.out.println(buf.indexOf("4"));//查

System.out.println(buf.append("123"));

System.out.println(buf.replace(1,2, "22"));//替换

System.out.println(buf.reverse());//反转

}

}

StringBuffer 和 StringBuilder

比较：StringBuffer 早于StringBuilder(快)

线程安全 StringBuffer 同步处理，性能稍慢

多线程使用

非线程安全 StringBuilder 并发处理，性能稍快

单线程使用

Java 中代表字符串的有 char[] String StringBuilder

char[] 只是字符数据,没有算法 用它就要自己实现方法 可能性能高 开发效率低

String 是不可变字符串 是最常用的字符串 java数据大多就是使用String 输出的

StringBuilder 是可变字符串，字符串的内容计算，建议采用StringBuilder实现，性能好

8个基本类型不是Object 的子类 也就是说 他们不是东西。

包装类 就是可以使8个基本类型可以参与到面向对象

都是final的

Byte byte

Short short

Integer int

Long long

Float float

Double double

还继承了java.lang.Object

-------------------------------------------

Character char

Boolean boolean

继承了java.lang.Object

---------------------------------------

创建的时候建议使用 常量池的方式 节省内存

Integer i = Intger.valueOf(1);

Integer i2 = new Integer(1);