常用类学习

包装类

1、针对8种基本数据类型相应的引用类型
2、有了类的特点就可以调用类中的方法

包装类与基本数据类型的转化

1）jd5之前的手动装箱和拆箱方式，装箱：基本类型>包装类型，反之，拆箱。
2）jdk5之后的自动装箱和拆箱方式
3）自动装箱底层调用的是valueOf方法，如Integer.valueOf()

package com.sun.wrapper;

/**
 * @Author:孙豪杰
 * @Version:1.0
 */
public class Integer01 {
    public static void main(String[] args) {
        //int和Integer装箱和拆箱
        //手动装箱和拆箱
        //手动装箱
        int n1 = 100;
        Integer integer = new Integer(n1);
        Integer integer1 = Integer.valueOf(n1);
        //手动拆箱
        int i = integer.intValue();

        //JDK5后自动装箱和自动拆箱
        int n2 = 200;
        //自动装箱
        Integer integer2 =n2;//底层使用的是Integer.valueOf(n2)
        //自动拆箱
        int n3 = integer2;//底层使用的是intValue()方法
    }
}

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

package com.sun.wrapper;

/**
 * @Author:孙豪杰
 * @Version:1.0
 */
public class WrapperString {
    public static void main(String[] args) {
        //包装类(Integer)>String
        Integer i = 100;//自动装箱
        //方式1：
        String str1 = i+ "";
        //方式2
        String str2 = i.toString();
        //方法3
        String str3 = String.valueOf(i);

        //String>包装类(Integer)
        String str4 = "12345";

        Integer i1 = Integer.parseInt(str4);//使用了自动装箱
        Integer i2 = new Integer(str4); //构造器
    }
}

包装类常用方法：
用到什么方法就查什么方法，通过类图查看

String类

String类的理解和创建

1、String对象用于保存字符串，也就是一组字符序列
2、字符串常量对象是用双引号括起来的字符序列
3、字符串的字符使用Unicode字符编码，一个字符（字母或汉字）占2个字节。
4、String类常用构造器

• new String()
• new String(String str)
• new String(char[] a)
• new String(char[] a ,int startIndex,int count)
  5、String实现接口Serializable【String可以串行化】、接口Comparable【String对象可以比较大小】。
  6、String是final类，不能被其他类继承
  7、字符串本质还是char数组（private final char value[];用于存放字符串内容
  8、注意value[]是一个final类型，赋值后不可修改（地址不可修改）。

串行化即可以在网络传输。
Comparable表示对象可以相互比较。

创建String对象的两种方式

1、直接赋值String s = “sun”;
先从常量池查查看是否有“hsp”数据空间，如果有，直接指向；如果没有则重新创建，然后指向。s最终指向的是常量池的空间地址

2、利用构造器
先在堆中创建空间，里面维护了value属性，指向常量池的sun空间。如果常量池没有“sun”；重新创建如果有，直接通过value指向。最终指向是堆空间地址。

注意：
equals就是比较内容
==就是需要判断引用是否相同

字符串特性

1、字符串是一个final类，代表不可变
2、字符串是不可变的，一个字符串对象一旦被分配，其内容是不可变的

 public static void main(String[] args) {
        String a = "dawda";
        String b = "dwa";
        //1、先创建一个StringBuilder sb = StringBuilder()
        //2、sb.append("dawda)
        //3、sb.append("dwa")
        //4、调用toString方法，返回String s= sb.toString()
        //最后c指向堆中的对象（String）value[]→池中"dawdadwa"
        String c = a+b;//所以需要创建3个对象
        //小结：常量相加是在池中，变量相加是在堆中
    }

注意：数组默认是放在堆里的。
只要调一个方法就会产生新的栈。

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

String的常用方法

equals：区分大小写，判断内容是否相等

；
注意：
对于特殊字符需要加上转义符
compareTo解读：如果长度相同返回0；如果长度相同，区分大小写，返回c1-c2；如果前面部分相同，返回c1.length-c2.length

StringBuffer

StringBuffer基本介绍

1、代表可变的字符序列
2、可以对字符串内容进行删减
3、StringBuffer是一个容器

StringBuffer特点：

1、StringBuffer的直接父类是AbstractStringBuffer
2、StringBuffer实现了 Serializable接口，可以串行化
3、在父类中AbstractStringBuffer有熟悉char[] value，不是final，该value数组存放字符串内容，在堆中存放。
4、StringBuffer是一个final类，不能被继承
5、因为StringBuffer字符内容是存在char[] value,所以在变化（增加/删除）不用每次都更换地址（即创建新的对象，效率高于String）

String和StringBuffer的区别：

• String保存的是字符串常量，里面的值不能更改，每次String类更新实际上就是更改地址，效率较低//private final char value[];
• StringBuffer保存的是字符串变量，每次值可修改，每次StringBuffer的更新实际上可以更新内容，不用每更新地址（当容量超出时更新地址），效率较高。//char[] value这个排在堆

StringBuffer构造器

1、StringBuffer()
创建一个初始长度为16的容器存放数据
2、StringBuffer(int i)
创建一个指定i长度的容器
3、StringBuffer(String str)
创建一个str长度加16的容器

String和StringBuffer的转化

String转为StringBuffer（两种方式）

 public static void main(String[] args) {
        String str = "dad ,wdq";
        //1.直接newStringBuffer
        StringBuffer stringBuffer = new StringBuffer(str);
        StringBuffer stringBuffer1 = new StringBuffer();
        //2.通过append方法
        stringBuffer1.append(str);
    }

StringBuffer转为String（两种方式）

//StringBuffer转为String
        //1.toString()方法
        StringBuffer stringBuffer2 = new StringBuffer("测试");
        String s =stringBuffer2.toString();
        //2.new String
        String s1 = new String(stringBuffer2);

StringBuffer常用方法

1、增append
2、删deletestart，end）区间为[start,end)
3、改replace（start，end，String）//将start–end内容替换为String，不含end
4、查indexof//查找字符串第一次的索引，如果找不到返回-1
5、插insert(index,String)在索引index的位置插入String，原来索引为index的位置后移
6、获取长度length

StringBuilder

介绍：
一个可变的字符序列，此类提供一个与StringBuffer兼容的API，但不保证同步（StringBuilder不是线程安全）。用在字符串缓冲区被单个线程使用时

StringBuilder主要操作是append和insert方法，可接受任意类型的数据

StringBuilder源码解读

1、继承了AbstractStringBuilder类
2、实现了Serializable，说明StringBuilder对象可以串行化（该对象可以网络传输和保存在文件中）
3、StringBuilder是final类，不能被继承
4、StringBuilder对象序列仍然是存放在父类AbstractStringBuilder的char[] value;因此字符序列在堆中
5、StringBuilder的方法没有做互斥的处理（无Synchronized关键字），因此在单线程的情况下使用

String、StringBuffer、StringBuilder比较

1、StringBuffer和StringBuilder非常类型，均代表可变字符序列，而且方法一样
2、String不可变字符序列，效率低，但是复用率高
3、StringBuffer：可变字符序列，效率高（增删）、线程安全
4、StringBuilder：可变字符序列，效率最高，线程不安全
5、String注意事项：
String s= "A”
执行s+=“b”,则字符串"A"已经丢弃，多次执行则会产生大量副本字符串留在内存中，效率较低，极大降低性能
结论：如果要对String做大量修改，建议不要使用StringBuffer

使用原则：

1. 如果字符串存在大量修改，一般使用StringBuffer或StringBulider
2. 如果字符串存在大量修改，并在单线程情况下，使用StringBuilder
3. 如果字符串存在大量修改，并在多线程情况下，使用StringBuffer
4. 如果字符串修改较少，被多个对象引用，使用String，比如配置信息等。

Math

常用方法：

• abs：绝对值
• pow：求幂
• ceil：向上取整
• floor：向下取整
• round：四舍五入
• sqrt：求开方
• random：求随机数【0,1)
• max：求两个数最大值
• min：求两个数最小值

Arrays类

Arrays里面包含静态方法，用于管理或操作数组（比如排序或搜索）
1、toString返回数组的字符串形式。
2、sort排序。

利用Sort做从大到小排序
		Integer [] arr = {2,3,54,23,5};
        Arrays.sort(arr, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                Integer i1 = (Integer)o1;
                Integer i2 = (Integer)o2;
                return i2 - i1;
            }
        });

自定义排序：

package com.sun.arrays_;
import java.util.Arrays;
import java.util.Comparator;

/**
 * @Author:孙豪杰
 * @Version:1.0
 */
public class ArraySortCustom {
    public static void main(String[] args) {
        int[] arr ={1,-1,8,0,20};
//      bubble01(arr);
        bubble02(arr, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                int i1 = (Integer)o1;
                int i2 = (Integer)o2;
                return i2 - i1;
            }
        });
        System.out.println("定制排序后的情况：");
        System.out.println(Arrays.toString(arr));

    }
    public static void bubble01(int[] arr){
        int temp = 0;
        for(int  i = 0;i<arr.length - 1;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 bubble02(int[] arr, Comparator c){
        int temp = 0;
        for(int  i = 0;i<arr.length - 1;i++){
            for(int j = 0; j < arr.length-1-i;j++){
                //数组方法
                if(c.compare(arr[j],arr[j+1])>0){
                    temp = arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }

            }
        }
    }
}

3、binarySearch通过二分搜索进行查找，要求必须排好序（返回查找的数的索引，不存在返回-1）。

4、conpyOf数组元素的复制
Arrays.copyOf(arr，arr.length);
如果拷贝的内容多了，则自动为空

5、fill数组元素的填充
Arrays.fill(int []arr，int)
使用int去替换所有arr数组元素

6、equals，比较两个数组元素的内容是否一致

7、asList，将一组值，转化为list集合

自定义排序练习

package com.sun.arrays_;



import java.util.Comparator;

/**
 * @Author:孙豪杰
 * @Version:1.0
 */
public class Test {
    public static void main(String[] args) {
        Book[] books = new Book[4];
        books[0] = new Book("a", 12);
        books[1] = new Book("b", 1);
        books[2] = new Book("c", 123);
        books[3] = new Book("d", 11);
        Book.bubble(books, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                int i1 = (Integer) o1;
                int i2 = (Integer) o2;
                return i2 - i1;
            }
        });
        for(Book book: books){
            System.out.println(book.toString());
        }

    }
}

class Book {
    String name;
    int price;

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

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

    public static void bubble(Book[] books, Comparator c) {
        Book temp = null;
        for (int i = 0; i < books.length - 1; i++) {
            for (int j = 0; j < books.length - i - 1; j++) {
                if (c.compare(books[j].price, books[j + 1].price) > 0) {
                    temp = books[j];
                    books[j] = books[j + 1];
                    books[j + 1] = temp;
                }
            }
        }
    }
}

System类

常见方法：
1、exit退出当前程序
2、arraycopy：复制数组元素比较适合底层调用，一般使用Arrays.copyOf完成复制数组。
3、currentTimeMillens：返回当前时间距离1970-1-1的毫秒数
4、gc：运行垃圾回收机制

BigInteger类和BigDecimal类

保存最大的值
BigInteger：

BigInteger bt = new BigInteger("2132131231");

1、进行加减乘除需要使用对应的方法
2、创建一个对应的BigInteger进行操作

BigDecimal和上面一样，但是做除法时可能除不尽，用以下方法：

divide(bigDecimal,BigDecimal.ROUND_CEILING)

Date日期、Calendar日历类及新日期

Date

Date：精确到毫秒，代表特定的瞬间
SimpleDateFormat：格式和解析日期的类
SimpleDateFormat格式化和解析日期的具体类。它允许进行格式化（日期→文本）、解析（文本→日期）和规范化

  //通过指定毫秒数获取时间
        Date date1 = new Date(212121);
        //获取某个时间对应的毫秒数
        date1.getTime();
        //格式化
        //1.创建SimpleDateFormat对象 ，可以指定相应的格式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 hh:mm:ss E");
        String format = sdf.format(date);
        System.out.println(format);
        //2.把字符串转为Date
        String s = "1996年01月01日 10:20:30 星期一";
        Date d1 = sdf.parse(s);
        System.out.println(d1);

Calendar

日历类

Calendar类是一个抽象类，它为特定瞬间与一组YEAR/MONTH/DAY_OF_MONTH/HOUR等日历字段之间的转化提供一些方法，并为操作日历字段提供方法。

新日期

Calendar不足分析
可变性：像日期和时间这样的类应该是不可变的
偏移性：Date中的年份是从1900开始的，而月份是从0开始的
格式化：格式化只对Date有用，Calendar则不行
不是线程安全：不能处理闰秒等。

第三代日期常用方法：
1）LocalDate（日期：年月日）、LocalTime（时间：时分秒）、LocalDateTime（日期时间：年月日时分秒）

 //第三代日期
        //1.使用now表示当前日期时间的对象
        LocalDateTime ldt = LocalDateTime.now();
        System.out.println(ldt);
        System.out.println("年："+ldt.getYear());
        System.out.println("月："+ldt.getMonth());
        System.out.println("年："+ldt.getMonthValue());
        System.out.println("日："+ldt.getDayOfMonth());
        System.out.println("时："+ldt.getHour());
        System.out.println("分："+ldt.getMinute());
        System.out.println("秒："+ldt.getSecond());
        LocalDate now = LocalDate.now();//可以获取年月日
        LocalTime now2 =LocalTime.now();//可以获取时分秒
        System.out.println(now.getYear());

2）DateTimeFormatter格式日期类

 LocalDateTime ldt = LocalDateTime.now();
        System.out.println(ldt);
        //DateTimeFormatter对象进行日期格式化输出
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH小时mm分钟ss秒");
        String format = dtf.format(ldt);

注意：只能在jdk1.8的手册中查看到这个类

3）Instant时间戳

Instant now = Instant.now();
        System.out.println(now);
        //转化为Date
        Date from = Date.from(now);
        System.out.println(from);
        //转化为Instant
        Instant instant = from.toInstant();

4）第三代日期更多方法

 LocalDateTime ldt =LocalDateTime.now();
        //提供plus和minus方法对当前的时间进行加减
        LocalDateTime plus = ldt.plusDays(890);
        LocalDateTime minus = plus.minusDays(890);
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH小时mm分钟ss秒");
        String format = dtf.format(plus);
        String format1 = dtf.format(minus);
        System.out.println(format1);

作业题

package com.sun.date_;

/**
 * @Author:孙豪杰
 * @Version:1.0
 */
public class Practice {
    public static void main(String[] args) {
        String s = "abcdef";
        try {
            System.out.println(reverse(s, 1, 6));
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
    public static String reverse(String str,int start ,int end){

        if(!(str!=null && start>=0 && end > start && end<str.length())){
            throw new RuntimeException("参数不正确");
        }

        //计算要转化的长度
        char[] chars = str.toCharArray();;

        char temp = ' ';
        for(int i = start,j=end; i<j;i++,j--){
            temp=chars[i];
            chars[i]=chars[j];
            chars[j]=temp;
        }
        String s = new String(chars);

        return s;


    }
}

编程技巧：
写出正确的情况，取反即可，这些写思路比较清晰

练习题2