常用类

包装类Wrapper

1. 针对八种基本数据类型相应的引用类型——包装类
2. 有了类的特点，可以调用类的方法

基本数据类型	包装类
boolean	Booblean
char	Character
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double

注：Object是所有类的父类，关系图中隐藏该父类

基本数据类型boolean对于的包装类关系图

基本数据类型char对应的包装类关系图

各数值类型对应包装类关系图

包装类和基本数据类型的转换

1. 装箱：基本类型转包装类型；反之为拆箱。
2. 自jdk5以后的自定装箱和拆箱方式
3. 自动装箱底层调用valueOf方法，如：Integer.valueOf()

public class Integer01 {
   public static void main(String[] args) {
      // jdk5以前
      // 手动装箱示范：int->Integer
      int num=10;
      Integer integer=new Integer(num);
      Integer integer1=Integer.valueOf(num);
      //手动拆箱
      int i=integer.intValue();
      // 自动装箱
      int num2=20;
      Integer integer2=num2;  // 底层用的是Integer.valueOf(num2)
      // 自动拆箱
      int num3=integer2;   // 底层任然使用intValue()方法

   }
}

其他包装类的用法同理

包装类和String类型的相互转换

Integer和String

 public class Wrapper {
   public static void main(String[] args) {
      // 方法一、包装类Integer转为String
      Integer i=10;  // 自动装箱
      // 以i为基本数值转成str1，对i的原数值没有影响
      String str1=i+"";
      // 方法二
      String str2 = i.toString();
      // 方法三
      String str3 = String.valueOf(i);
      String str4="123456";
      // String->包装类（Integer）
      Integer.parseInt(str4);
      Integer i2=Integer.parseInt(str4);// 自动装箱
      Integer i3=new Integer(str4); // 构造器
   }
}

包装类方法

Integer类和Character类的常用方法。其他方法需要使用时自行查找。

public class Wrapper {
   public static void main(String[] args) {
      System.out.println(Integer.MIN_VALUE); //返回最小值
      System.out.println(Integer.MAX_VALUE);//返回最大值
      System.out.println(Character.isDigit('a'));//判断是不是数字
      System.out.println(Character.isLetter('a'));//判断是不是字母
      System.out.println(Character.isUpperCase('a'));//判断是不是大写
      System.out.println(Character.isLowerCase('a'));//判断是不是小写
      System.out.println(Character.isWhitespace('a'));//判断是不是空格
      System.out.println(Character.toUpperCase('a'));//转成大写
      System.out.println(Character.toLowerCase('A'));//转成小写
   }
}

String

1. String对象用于保存字符串，也就是一组字符序列
2. 字符串常量对象是用双引号括起的字符序列。例如："hello"。
3. 字符串的字符使用Unicode字符编码，一个字符占两个字节（不区分字母还是汉字）。
4. String类常用的构造方法

• String s1=new String();
• String s2=new String(String original);
• String s3=new String(char[] a);
• String s1=new String(char a,int starIndex,int count);

String类图结构

1. String实现了Serializable接口，说明String可以串行化；可以在网络上传输。
2. Sting实现了Comparable接口，说明String可以比较。
3. String是final类；不能被继承。
4. String有属性  private final char value[];用于存放字符串内容，value是一个final类型，地址不可修改（value不能指向新地址，但是单个字符内容可修改）。

public class Str {
    public static void main(String[] args) {
        String s = "rick";
        final char[] value = {'a', 'b', 'c'};
        char[] value2 = {'d', 'e', 'f'};
        // value=value2; final约束不可以修改value地址
        value[0] = 'B';
        for (int i = 0; i < value.length; i++)
            System.out.println(value[i]);
    }
}

创建String对象的两种方式

• 方式一，直接赋值：String s="hello";
• 方式二，调用构造器：String s2=new String("hello");

1. 方式一：先从常量池查看是否有"hello"数据空间，如果有，直接指向；没有则重新创建然后指向。s最终指向常量池的空间地址。
2. 方式二：先在堆中创建空间，里面维护value属性，指向常量池的hello空间。如果常量池没有"hello"，重新创建，有则直接通过value指向。最终指向的是堆中的空间地址。

创建String对象两种方式的内存布局图

调用intern方法时如果池中已经包含一个等于此String对象的字符串（用equals(Object)方法确定）。则返回池中字符串，否则，把String对象的字符串添加到池中，并返回对象的引用。

public class _Str {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = new String("hello");
        System.out.println(s1.equals(s2));
        System.out.println(s1 == s2.intern());    // s2.intern最终返回的是常量池中的常量池地址
        System.out.println(s1 == s2);
    }
}

String内存布局示范代码（根据代码画出内存布局图掌握内存布局）

public class _Str {
   public static void main(String[] args) {
      Person person = new Person();
      person.name="rick";
      Person person1 = new Person();
      person1.name="rick";
      System.out.println(person.name.equals(person1.name));
      System.out.println(person==person1);
      System.out.println(person.name=="rick");
      String s1=new String("hi");
      String s2=new String("hi");
      System.out.println(s1==s2);
   }
}
class Person{
   public String name;
}

字符串的特性

public class _Str {
   public static void main(String[] args) {
      String s1="hi"+"rick";  // 编译器会优化为[String s1="hirick"；]所以会创建一个对象
      String s2="ab";
      String s3="cd";
      String s4=s2+s3;  //执行步骤：
      // 1.创建一个StingBuilder s=new StringBuilder()
      // 2.执行s.append("ab");
      // 3.执行s.append("cd");
      // 4.执行String s4 = s.toString();
      // 最终s4指向堆中的对象(String)value[]->常量池中的"abcd"
      String s5="abcd";
      System.out.println(s4==s5);
      System.out.println(s4.equals(s5));

      T t = new T();
      t.chage(t.str0, t.ch);
      System.out.println(t.str0);
      System.out.println(t.ch);
   }
}
class T {
   String str0 = new String("hello");
   final char[] ch = {'j', 'a', 'v', 'a'};

   public void chage(String str,char ch[]) {
      str0 = "java";
      ch[0] = 'N';
   }
}

String的常用方法

String类是保存字符串常量的。每次更新都需要重新开辟空间，效率低，所以java设计者提供了StringBuffter和StringBuild增强String的功能，并提高效率。

String常用方法

public class _StrMethod {
    public static void main(String[] args) {
        String str1 = "hello";
        String str2 = "Hello";
        System.out.println(str1.equals(str2));//比较两个字符串内容
        // 2.equalsIgnoreCase 忽略大小写的判断内容是否相等
        String username = "johN";
        if ("john".equalsIgnoreCase(username)) {
            System.out.println("Success!");
        } else {
            System.out.println("Failure!");
        }
        // 3.length 获取字符的个数，字符串的长度
        System.out.println("Jack三".length());
        // 4.indexOf 获取字符在字符串对象中第一次出现的索引，索引从 0 开始，如果找不到，返回-1
        String s1 = "wer@terwe@g";
        int index = s1.indexOf('@');
        System.out.println(index);// 3
        System.out.println("weIndex=" + s1.indexOf("we"));//0
        // 5.lastIndexOf 获取字符在字符串中最后一次出现的索引，索引从 0 开始，如果找不到，返回-1
        s1 = "wer@terwe@g@";
        index = s1.lastIndexOf('@');
        System.out.println(index);//11
        System.out.println("ter 的位置=" + s1.lastIndexOf("ter"));//4
        // 6.substring 截取指定范围的子串
        String name = "hello,张三";
        //下面 name.substring(6) 从索引 6 开始截取后面所有的内容
        System.out.println(name.substring(6));//截取后面的字符
        //name.substring(0,5)表示从索引 0 开始截取，截取到索引 5-1=4的位置
        System.out.println(name.substring(0, 5));//hllo
        // 1.toUpperCase 把字符串内字母全部转换成大写
        String s2 = "HEllo";
        System.out.println(s2.toUpperCase());
        // 2.toLowerCase 把字符串内所有字符转为小写
        System.out.println(s2.toLowerCase());
        String s3 = "jack";
        //
        s3 = s3.concat("hello").concat("every").concat("day");
        System.out.println(s3);
        s3 = "jackhelloeveryday";
        // replace 把s3中所有hello 换成Hi,注意方法只对返回的结果处理，对原数据没有影响
        s3 = s3.replace("hello", "Hi");
        System.out.println(s3);
        String s4 = "Aa,Bb,Cc,Dd,Ee";
        // 以 , 为标准进行分割返回一个数组
        String[] split = s4.split(",");
        System.out.println("逗号分隔开的单个数据分别是：");
        for (int i = 0; i < split.length; i++) {
            System.out.println(split[i]);
        }
        String s5 = "hello";
        // toCharArray 把字符串转为字符数组
        char[] chars0 = s5.toCharArray();
        for (int i = 0; i < chars0.length; i++) {
            System.out.println(chars0[i]);
        }
        // compareTo 比较两个字符串大小前者大返回正数否则为负相等为0
        // 1.长度相同，每个字符相同返回0 2.长度相同或不同，比较时可以区分大小写就返回s6-s7(具体查看源码)3.前面部分相同就s6.length-s7.length
        String s6 = "rick";
        String s7 = "jack";
        System.out.println(s6.compareTo(s7));// 返回 s7-s6的值
        String name1="tom";
        int age=18;
        double score=97.5/3;
        char gender='男';
        String show="姓名"+name1+"年龄"+age+"平均成绩"+score+"性别"+gender;
        System.out.println(show);
        // %s,%d 等这些叫做占位符，由后面的变量来替换，占位符具体用法查看C语言
        String info=String.format("年龄%s年龄%d平均成绩%.2f性别：%c",name1,age,score,gender);
        System.out.println(info);
    }
}

 其他方法通过jdk api 1.8_google文档查看

StringBuffer类

java.lang.StrinngBuffer代表可变的字符序列，可以对字符串内容进行增删。很多方法与String相同，但StringBuffer是可变长度的。

1. StrinngBuffer直接父类是AbstractStringBuilder
2. StringBuffer实现了Serializable，即StringBuffer的对象可以串行
3. 在父类AbstractStringBuilder中有属性char[] value，不是final。
4. 该value数组存放字符串内容，所以存放在堆中（不是常量池）。
5. StringBuffer是一个final类。

String对比StringBuffer

• String保存的是字符串常量，里面的值不能修改，String每次更新实际上是更新地址效率低（本质原因是private final char value[];）
• StringBuffer保存的是字符串变量，里面的值可以修改，且修改内容不用每次更新地址效率高（char value[]; 存放在堆中）

StringBuffer构造器

StringBuffer构造器

 public class Buffer {
   public static void main(String[] args) {
      StringBuffer stringBuffer = new StringBuffer(); // 创建一个大小为16的char[]，用于存放字符内容
      StringBuffer stringBuffer2 = new StringBuffer(100); // 指定创建一个大小为100的char[]。
      StringBuffer hello = new StringBuffer("hello"); // 通过给String创建一个StringBuffer，char[]大小就是一个str.length+16
   }
}

String和StringBuffer的相互转换

查看代码

 public class StringAndBuffer {
    public static void main(String[] args) {
        // String转为StringBuffer
        String str="hi rick";
        // 使用构造器转换
        StringBuffer stringBuffer = new StringBuffer(str);  //返回的才是StringBuffer对象对String本身没有影响
        // 使用append方法
        StringBuffer stringBuffer1 = new StringBuffer();
        stringBuffer1= stringBuffer1.append(str);
        // StringBuffer转String
        StringBuffer stringBuffer2 = new StringBuffer("hello,jack");
        // 使用StringBuffer提供的toString方法直接转换
        String s = stringBuffer2.toString();
        // 使用构造器
        String s1 = new String(stringBuffer2);

    }
}

StringBuilder类

是一个可变的字符序列，此类提供一个与StringBuffer兼容的API，但是不保证同步（StringBuilder存在多线程问题）。该类被设计用于StringBuffer的简易替换，用在字符串缓冲区被单个线程使用时。如果可能，建议优先采用该类，因为多数情况下，他比StringBuffer更快。

1. 通过继承关系图得知StringBuilder继承了AbstractStringBuilder类
2. 实现了Serializable，说明StringBuilder对象是可以串行化（该对象可以网络传输，也可以保存到文件）同时还是final类
3. StringBuilder对象字符依旧存放在其父类AbstractStringBuilder类，所以字符序列存放在堆中
4. StringBuild的方法，没有做互斥处理（没有synchronized关键字，因此推荐在多线程的情况下使用）

在StringBuilder上的主要操作是append和insert方法，可重载这些方法，以接受任意类型。

String、StringBuilder、StringBuffer的比较

1. StringBuilder和StringBuffer非常类似均代表可变的字符序列，且方法一样。
2. String：不可变字符序列，效率低、但是代码复用率高
3. StringBuffer：可变字符序列，增删效率较高、线程安全（源码可以看到方法被synchronized修饰）。
4. StringBuffer：可变字符序列，效率最高、线程不安全。

      String s="a";  // 创建了一个字符串
      s+="b";  // 实际上原来的“a”对象已经丢弃，现在产生新字符串s+"b"("ab")
      //如果多次执行（循环）这些改变字符串操作会导致大量字符串对象存留在内存中，降低效率
      System.out.println("结论：如果这样的操作放在循环中会极大地影响性能，所以对String做大量修改时，不要用String而是StringBuffer。");

使用总结：

1. 如果字符串存在大量修改操作，通常使用StringBuffer（多线程）或StringBuilder（单线程）
2. 如果修改字符串操作较少，被多个对象引用，使用String，如配置信息等

Math类

基本介绍：包含用于基本数学运算的方法（均为静态方法），例如初等指数，对数、平方根、三角函数。

Math常用方法

 public class MathMethod {
    public static void main(String[] args) {
       System.out.println("Math常用的方法");
       //看看 Math 常用的方法(静态方法)
       //1.abs 绝对值
       int abs = Math.abs(-9);
       System.out.println(abs);//9
       //2.pow 求幂
       double pow = Math.pow(2, 4);//2 的 4 次方
       System.out.println(pow);//16.0
       //3.ceil 向上取整,返回>=该参数的最小整数(转成 double);
       double ceil = Math.ceil(3.9);
       System.out.println(ceil); //4.0
       //4.floor 向下取整，返回<=该参数的最大整数(转成 double)
       double floor = Math.floor(4.001);
       System.out.println(floor);//4.0
       //5.round 四舍五入 Math.floor(该参数+0.5)
       long round = Math.round(5.51);
       System.out.println(round);//6
       //6.sqrt 求开方
       double sqrt = Math.sqrt(9.0);
       System.out.println(sqrt);//3.0
       //7.random 求随机数
       // random 返回的是 0 <= x < 1 之间的一个随机小数
       // a=2,b=7,=> (int)(a+Math.random()*(b-a+1))=(int)(2+Math.random()*6)
       for (int i = 0; i < 100; i++) {
          System.out.print((int) (2 + Math.random() * (7 - 2 + 1))+" ");
       }
       System.out.println("\n获取a-b之间的随机整数公式：int number=(int)(Math.random()*(b-a+1)+a)");
       //max , min 返回最大值和最小值
       int min = Math.min(1, 9);
       int max = Math.max(45, 90);
       System.out.println("\nmin=" + min);
       System.out.println("max=" + max);
    }
}

Array类

public class ArrayMethod {
    public static void main(String[] args) {
        Integer[] integers = {1, 2, 3};
        // 遍历数组
      /*for (int i = 0; i < integers.length; i++) {
         System.out.println(integers[i]);
      }*/
        // 直接使用Array.toString方法，显示数组
        System.out.println(Arrays.toString(integers));  // 查看toString（选中【Ctrl】+【b】）方法可以知道返回的内容
        Integer arr[] = {-1, 2, -3, 4, 5, -6, 7, 0};
        // 进行排序 1、可以使用冒泡排序，也可以直接使用Array.sort方法直接排序
        Arrays.sort(arr); // 默认排序；因为数组是引用类型传入的是地址排序后会修改实参arr
        Arrays.sort(arr, new Comparator() { // 调用定制排序时，传入两个参数1.排序数组arr，2.实现Comparator()接口的匿名内部类
           // 源码分析1、Array.sort(arr,new Comparator())
           // 2、最终到 TimSort的 private static <T> void binarySort(T[] a, int lo, int hi, int start,
           //                                       Comparator<? super T> c) ()
           // 3、执行到binarySort方法的代码，会根据动态绑定机制c.compare()执行传入的匿名内部类的compare()
           // while (left < right) {
           //                int mid = (left + right) >>> 1;
           //                if (c.compare(pivot, a[mid]) < 0)
           //                    right = mid;
           //                else
           //                    left = mid + 1;
           //            }
           // 4、执行传入的匿名内部类
           // 5、 public int compare(Object o1, Object o2) 返回的值>0还是<0 会影响整个排序的结果

            @Override
            public int compare(Object o1, Object o2) {   // 要求实现compare方法
                Integer i1 = (Integer) o1;
                Integer i2 = (Integer) o2;
                return i1-i2; // 从小到大；体现接口编程的方式（对匿名内部类下断点调试）
              //  return i2-i1;
            }
        });
        // sort是重载的也可以通过传入一个Comparator实现定制排序
        System.out.println(Arrays.toString(arr));
    }
}

查看代码

 public class ArrayCustomSort {
    public static void main(String[] args) {
        int arr[] = {0, -1, 2, 3, -5, -10};
        bubble1(arr);
        System.out.println("冒泡排序后");
        System.out.println(Arrays.toString(arr));
        bubble2(arr, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                int i1 = (Integer) o1;   //拆箱
                int i2 = (Integer) o2;
                // return i1 - i2;  // 小到大
                 return i2-i1;  //大到小
            }
        });
        System.out.println("自定义排序后："+Arrays.toString(arr));
    }

    // 冒泡排序
    public static void bubble1(int arr[]) {
        int temp = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {   // 从小到大
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

    // 改进
    public static void bubble2(int[] arr, Comparator comparator) {
        int temp = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                // 数组的排序由comparator.compare(arr[j], arr[j + 1])返回的值决定
                if (comparator.compare(arr[j], arr[j + 1]) > 0) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
}

二分查找

 public class ArrayMethod {
    public static void main(String[] args) {
        // binarySearch通过二分查找，要求必须是排序好(有序的)的数组
        Integer[] arr = {-1,0,1,2,3,4,6,8,10};
        int index=Arrays.binarySearch(arr,10);
        System.out.println(index);  // 数组不存在查找的元素则返回return -(low + 1); low指查找元素应该存在的位置
    }
}

Array常用类

 public class ArrayMethod {
    public static void main(String[] args) {
        // binarySearch通过二分查找，要求必须是排序好(有序的)的数组
        Integer[] arr = {-1,0,1,2,3,4,6,8,10};
        int index=Arrays.binarySearch(arr,10);
        System.out.println(index);  // 数组不存在查找的元素则返回return -(low + 1); low指查找元素应该存在的位置
        // copyOf 数组元素复制:从arr数组中拷贝arr.length个元素到newArr数组中。
        // 拷贝的长度大于arr.length，超出部分添加null，拷贝长度小于0抛出异常
        // 底层使用System.arraycopy()
        Integer[] newArr=Arrays.copyOf(arr,arr.length);
        System.out.println("复制的数组："+Arrays.toString(newArr));

        // ill数组元素填充
        Integer num[]=new Integer[]{77,177,777};
        // 用99填充num数组换言之用99替换所有原来的元素
        Arrays.fill(num,99);
        System.out.println("数组填充后："+Arrays.toString(num));
        // equals 比较两个数组是否完全一致
        Integer[] arr2 = {-1,0,1,2,3,4,6,8,10};
        // 如果arr和arr2数组元素一样返回true
        // 如果不完全一样返回false
        boolean equals=Arrays.equals(arr,arr2);
        System.out.println(equals);
        // asList把一组值转为list
        // asList方法，会把(2,3,4,5,8,-1,0)数据转为一个集合
        // 返回的asList变异类型List接口
        // asList运行类型是Array类的静态内部类：private static class ArrayList<E> extends AbstractList<E>
        //        implements RandomAccess, java.io.Serializable
        List<Integer>asList=Arrays.asList(2,3,4,5,8,-1,0);
        System.out.println("aslist="+asList);
        System.out.println("asList的运行类型是"+asList.getClass());
    }
}

Array应用练习

 public class ArrayMethod {
    public static void main(String[] args) {
        Book[] books = new Book[4];
        books[0] = new Book("01", 100);
        books[1] = new Book("002", 200);
        books[2] = new Book("0003", 300);
        books[3] = new Book("00004", 400);
        //price从小到大
        Arrays.sort(books, new Comparator<Book>() {
            @Override
            public int compare(Book o1, Book o2) {
                Book book1 = (Book) o1;
                Book book2 = (Book) o2;
                double val = book2.getPrice() - book1.getPrice();
                if (val > 0) {
                    return -1;
                } else if (val < 0) {
                    return 1;
                } else {
                    return 0;
                }
            }
        });
        System.out.println(Arrays.toString(books));
        //price从大到小
        Arrays.sort(books, new Comparator<Book>() {
            @Override
            public int compare(Book o1, Book o2) {
                Book book1 = (Book) o1;
                Book book2 = (Book) o2;
                double val = book2.getPrice() - book1.getPrice();
                if (val > 0) {
                    return 1;
                } else if (val < 0) {
                    return -1;
                } else {
                    return 0;
                }
            }
        });
        System.out.println("\n" + Arrays.toString(books));
        // 按书名长度排序，长到短
        Arrays.sort(books, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                Book book1 = (Book) o1;
                Book book2 = (Book) o2;
                return book2.getName().length() - book1.getName().length();
            }
        });
        System.out.println("\n" + Arrays.toString(books));
    }
}

class Book {
    private String name;
    private double price;

    public Book(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                "price=" + price +
                '}' + "\n";
    }
}