笔记(课7)

一阶段：第7天：包装类和字符串（7.31）

一.包装类

1.1基本数据类型所对应的包装类

​ byte 　Byte
​ short 　Short
​ int 　Integer
​ long 　Long
​ float 　Float
​ double Double
​ char 　Character
​ boolean Boolean

1.2数据的装箱和拆箱

装箱：将基本类型数据包装成引用类型数据

拆箱：将包装类型数据转换成基本类型数据

装箱：使用包装类中的构造方法，或静态valueOf方法

		int a = 5;
		Integer i = new Integer(a);//构造方法
		double b = 3.0;
		Double d = Double.valueOf(b);//静态valueOf()方法

拆箱：使用包装类中的xxValue方法

		Integer i = new Integer(5);
		int a = i.intValue();

		int a = 5;
		Integer i = a;// Integer.valueOf(a);

自动装箱和自动装箱：jdk1.5之后新增的功能
自动装箱：可以直接将基本类型数据赋值给包装类对象
​自动拆箱：直接将包装类对象数据赋值给基本类型变量

public class Demo1 {
    public static void main(String[] args) throws Exception{
        Integer integer1 = 100;
        Integer integer2 = 100;
        System.out.println(integer1==integer2);
        Integer integer3=200;
        Integer integer4=200;
        System.out.println(integer3==integer4);
        //字符串转基本类型
        String s1="1010";
        int n1=Integer.valueOf(s1);
        int n2=Integer.parseInt(s1,2);
        System.out.println("n1:"+n1+" n2:"+n2);
        String s2="true";
        boolean n3=Boolean.valueOf(s2);
        boolean n4=Boolean.parseBoolean("true");
        System.out.println("n3:"+n3+" n4:"+n4);
        String s3="1010";
        String s4=Integer.toBinaryString(255);
        System.out.println("s3:"+s3+" s4:"+s4);
        System.out.println("-----------");
        String s11="hello";
        s11="zhangsan";
        String s12="zhangsan";
        System.out.println(s11);
        System.out.println(s12);
        System.out.println(s11==s12);
        System.out.println("-------------");
        String s13=new String("zhangsan");
        String s14=new String("zhangsan");
        System.out.println(s13==s14);
        System.out.println("-----修改value[]-----");//用的反射技术
        //获取String的类对象
        Class<? extends String> class1=s11.getClass();
        //获取String value属性
        Field field=class1.getDeclaredField("value");
        //设置访问权限
        field.setAccessible(true);
        //获取value的值
        char[] v=(char[]) field.get(s11);
        System.out.println("v的长度"+v.length);
        v[0]='x';
        System.out.println(s12);
        System.out.println(s13);
        System.out.println(s14);
        //面试题：String name=new String("少泊");创建了几个对象:2个
    }
}

二.字符串

2.1 String类

2.1.1 获取出现的位置

获取某个字符或者字符串在原字符串中第一次出现的位置

     int indexOf(int ch)   
        返回指定字符在此字符串中第一次出现处的索引。 
	 int indexOf(int ch, int fromIndex) 
        返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。 
	 int indexOf(String str)	  
        返回指定子字符串在此字符串中第一次出现处的索引。 
	 int indexOf(String str, int fromIndex) 
        返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。

获取某个字符或者字符串在原字符串中最后一次出现的位置
注意：从左往右进行查询，获取到的索引仍然是在原字符串中的索引

    int lastIndexOf(int ch) 
         返回指定字符在此字符串中最后一次出现处的索引。 
	int lastIndexOf(int ch, int fromIndex) 
         返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。 
	int lastIndexOf(String str) 
         返回指定子字符串在此字符串中最右边出现处的索引。 
	int lastIndexOf(String str, int fromIndex) 
         返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。

2.1.2获取某个位置上的字符

char charAt(int index)

	//返回指定索引处的 char 值。 
	char ch = s.charAt(6);//获取s字符串中索引为6的字符

2.1.3判断字符串中是否包含某个子字符串

boolean contains(CharSequence s)

	//当且仅当此字符串包含指定的char值序列时，返回 true。 
	//注意：判断包含的内容必须是连续的
	boolean b1 = s.contains("hello");//判断s字符串是否包含"hello"字符串

2.1.4 判断字符串中是否有内容

boolean isEmpty()

    //当且仅当 length() 为 0 时返回 true。 
	boolean b2 = s.isEmpty();//判断s字符串是否是空字符串

2.1.5判断字符串是否是以某个前缀开始的

boolean startsWith(String prefix)

    boolean b3 = s.startsWith("hello");//判断s字符串是否以"hello"开头

2.1.6判断字符串是否是以某个后缀结束的

判断字符串是否是以某个后缀结束的

    boolean b4 = s.endsWith("hello");//判断s字符串是否以"hello"结尾

2.1.7忽略大小写相等比较

boolean equalsIgnoreCase(String anotherString)

     boolean b6 = "Abc".equalsIgnoreCase("abc");//true
	 boolean b7 = "Abc".equals("abc");//false

2.1.8替换

String replace(char oldChar, char newChar)
返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
String replace(CharSequence target, CharSequence replacement)
使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。

    String s = "hello java";
	//注意：会替换原字符串中所有的指定字符
	String s1 = s.replace('a','k');
	System.out.println(s1);
	//注意：将要替换的字符串可以和被替换的字符串长度不相等，当做一个整体被替换掉
	String s2 = s.replace("java","php");
	System.out.println(s2);

2.1.9截取

String substring(int beginIndex)
返回一个新的字符串，从指定的下标开始截取后半部分。
String substring(int beginIndex, int endIndex)
包头不包尾，返回一个新字符串，截取指定区间的子字符串。

		String str2 = str1.substring(3);
		System.out.println(str2);
		String str3 = str1.substring(3,9);
		System.out.println(str3);

2.1.10去除前面和尾部的空格

String trim()

    String string1 = "   hello    hello  ";
	String string2 = string1.trim();
	System.out.println(string2);

2.1.11将字符串按照指定的格式输出

String.format(String format, Object… args)
使用指定的格式字符串和参数返回一个格式化字符串。
%f 　 float
%d 　整型
%s 　字符串
%c 　char
%b 　boolean

        //注意：可以保留小数点后几位
		String string3 = String.format("%.2f--%b--%s",10.23766f,true,"hello");
		System.out.println(string3);
		System.out.println("hello" + 10.23766f + true);

2.1.12比较

int compareTo(String anotherString) 按字典顺序比较两个字符串。
int compareToIgnoreCase(String str) 按字典顺序比较两个字符串，不考虑大小写。
如果按字典顺序此 String 对象位于参数字符串之前，则比较结果为一个负整数。
如果按字典顺序此 String 对象位于参数字符串之后，则比较结果为一个正整数。
如果这两个字符串相等，则结果为 0.
如果比较的字符长度不同，先比较前边几个是否相同，如相同再比较长的，结果才是长度差值

		int num1 = "abc".compareTo("def");//-3
		int num2 = "def".compareTo("abc");//3
		int num3 = "abc".compareTo("abc");//0
		int num4 = "abc".compareTo("defbbbbb");//-3
		int num5 = "abc".compareTo("abcaaaaa");//-5

2.1.13拼接

String.concat(String str) 将指定字符串连接到此字符串的结尾。
注意：在String类中，但凡返回值是String类型的方法，生成的都是一个新的字符串，跟原来的字符串没有关系

		String newStr = str1.concat("hello");
		System.out.println(str1);//welcome to china
		System.out.println(newStr);//welcome to chinahello

2.1.14拆分

String.split(String str)按照指定字符进行分割拆分，得到的是一个String数组

        String s12="北京,上海,广州,深圳";
		String[] cities=s12.split(",");
		System.out.println(cities.length);
		for (String c : cities) {
			System.out.println(c);
		}

综合案例1

public class Demo2 {
    public static void main(String[] args) {
        String str="this is a    text";
        //将str中的单词单独提取出来
        String[] arr=str.split(" +");
        System.out.println("arr的长度:"+arr.length);
        for (String s : arr) {
            System.out.println(s);
        }
        //将str中的text替换为practice
        String str2=str.replace("text", "practice");
        System.out.println(str2);
        //在text前面插入一个easy
        String str3=str.replace("text", "easy text");
        System.out.println(str3);
        //将每个单词首字母变成大写
        String str4="";
        for (int i = 0; i < arr.length; i++) {
            //把字母变成大写
            char first=Character.toUpperCase(arr[i].charAt(0));
            //组成首字母大写的单词
            String s=first+arr[i].substring(1);
            str4+=s+" ";
        }
        //str4=str4.substring(0,str4.length());
        str4=str4.trim();
        System.out.println(str4);
    }
}

字符串存储空间

1. 使用一个字符串常量定义两个不同的变量，这时两个变量其实在内存中是同一块内存空间
   原因：两个变量都拷贝了字符串常量的地址
2. 但凡遇到new关键字，表示开辟了不同的空间
3. 字符串是一个特殊的对象，一旦被初始化之后将不能发生改变。注意：不能发生改变指的是真正的对象【字符串常量对象和new出现的对象】
4. String str = “abc”;等价于char[] arr = {‘a’,‘b’,‘c’};

2.2StringBuffer类

字符串缓冲区：使用缓冲区操作字符串要比直接操作字符串效率高

2.2.1常用的成员方法

1. 追加:append()
2. 删除：
   （1）删除指定区间的字符串：sb1.delete(2,3);
   （2）删除指定位置上的字符：sb1.deleteCharAt(0);
3. 替换：
   （1）替换指定区间的字符串：sb1.replace(2,5,“nnnnnn”);
   （2）替换指定位置上的字符：sb1.setCharAt(0,‘x’);
4. 获取：indexOf()，lastIndexOf()，charAt()，length()，substring()和String类中的用法相同
5. 反转：StringBuffer reverse()

       StringBuffer sb3 = new StringBuffer("my name is zhansan");
	   sb3.reverse();

2.3StringBuilder类

StringBuilder类也是字符串缓冲区，类中的方法与StringBuffer类中的方法使用方法一样，区别在于StringBuilder类中的方法都是线程不安全的，而StringBuffer类中的方法都是线程安全。
StringBuilder效率比StringBuffer的高。

2.4 String.inter()方法

intern方法用来返回常量池中的某字符串，如果常量池中已经存在该字符串，则直接返回常量池中该对象的引用。否则，在常量池中加入该对象，然后返回引用。

intern()方法总结：

1.只在常量池上创建常量
    String a1 = "AA";
2.只在堆上创建对象
    String a2 = new String("A") + new String("A");
3.在堆上创建对象，在常量池上创建常量
    String a3 = new String("AA");
4.在堆上创建对象，在常量池上创建引用
    String a4 = new String("A") + new String("A");//只在堆上创建对象AA
    a4.intern();//将该对象AA的引用保存到常量池上
5.在堆上创建对象，在常量池上创建引用,不会在常量池中再创建常量。
    String a5 = new String("A") + new String("A");//只在堆上创建对象
    a5.intern();//在常量池上创建引用
    String a6 = "AA";//此时不会再在常量池上创建常量AA，而是将a5的引用返回给a6
    System.out.println(a5 == a6); //true

public class Demo3 {
    public static void main(String[] args) {
        System.out.println("----java 特殊----");
        //就算分开创建，只要最后数据内容为java，就会在常量池中自动创建“java”常量
        String a1=new String("ja")+new String("va");
        String s1=a1.intern();
        String a2=new String("ja")+new String("va");
        System.out.println(a1==s1);
        System.out.println(a1==a2);
        System.out.println(a2==s1);
        String ab1=new String("ja")+new String("va");
        String sb1=a1.intern();
        String ab2=new String("ja")+new String("va");
        System.out.println(a1==s1);
        System.out.println(a1==a2);
        System.out.println(a2==s1);
        System.out.println("-----------");
        String a11=new String("A")+new String("a");
        String s11=a11.intern();
        String a21=new String("A")+new String("a");
        System.out.println(a11==s11);
        System.out.println(a11==a21);
        System.out.println(a21==s11);
        System.out.println("-----------");
        String x1="hello"+"world";//优化了，只有一个helloworld
        String y1=x1.intern();
        String x2="helloworld";
        System.out.println(x1==y1);
        System.out.println(x1==x2);
        System.out.println(x2==y1);
    }
}
结果：
----java 特殊----
false
false
false
false
false
false
-----------
true
false
false
-----------
true
true
true

2.5正则表达式（Regular Expression）

预定义字符类
  .		    任意字符（与行结束符可能匹配也可能不匹配）
  \d		数字：[0-9]
  \w		单词字符：[a-zA-Z_0-9]
边界匹配器
  ^		行开头
  $		行结尾
数量：
  X?			一次或0次
  X*			0次或多次(包括1次)
  X+			一次或多次
  X{n}		    恰好n次
  X{n, }		至少n次
  X{n,m}		至少n次，不超过m次

扩展：
Pattern类 ：正则表达式编译类
Matcher类：匹配器

 * 正则表达式的使用(Regular Expression)
public class Demo1 {
    public static void main(String[] args) {
        //(1)匹配
        String phone="13167371397";
        String reg="1[35789]\\d{9}";//两个\\等于一个\
        boolean b=phone.matches(reg);
        System.out.println(b);
        System.out.println("---------拆分----------");
        String content="i am lihua,welcome to beijing";
        String[] contents=content.split("[, ]");
        System.out.println(contents.length);
        for (String s : contents) {
            System.out.println(s);
        }
        //Pattern(模式) Matcher(匹配器)
        boolean b1= Pattern.matches("[\\d]", "aaaa");
        System.out.println(b1);

        //获取
        String con="java是世界上最好的语言，Java真棒，JAVA牛";
        String rege="([jJ]ava)|(JAVA)";
        Pattern pattern=Pattern.compile(rege);
        Matcher matcher=pattern.matcher(con);
        while (matcher.find()) {
            System.out.println(matcher.group());
        }
        //替换
        String con2=con.replaceAll(rege,"php");
        System.out.println(con2);

        //扩展案例
        String say="我喜..喜喜欢欢欢欢...编编.....程程...";
        //1.替换
        String say2=say.replaceAll("\\.", "");//\\.相当于.(因为.有特殊含义\是转义字符的标志，所以要再加个\)
        System.out.println(say2);
        //2.把重复的汉字替换为一个
        String say3=say2.replaceAll("(.)\\1+","$1" );//"(.)(.)\\1+\\2+","$2"
        System.out.println(say3);

        String ceshi="我喜欢..喜欢喜欢喜欢喜欢喜欢...编编.....程程...";
        String ceshi1=ceshi.replaceAll("\\.", "");
        System.out.println(ceshi1);
        String ceshi2=ceshi1.replaceAll("((.)(.)\\2\\3)+","$2$3" );//或者写成(.)(.)(\\1\\2)+
        System.out.println(ceshi2);
        String ceshi3=ceshi2.replaceAll("(.)\\1+","$1" );
        System.out.println(ceshi3);
    }
}