1、包装类

包装类(Wrapper Class),8种基本数据类型分别对应一个包装类,包装类均位于java.lang包

包装类的优点:

1. 某些方法的参数必须是对象,为了让基本数据类型的数据作为参数,提供包装类
2. 包装类还提供更多的功能例如:
   1. 获得类型的最大值:
      
Integer.MAX_VALUE

   2. 最小值
      
Integer.MIN_VALUE

   3. 将一个类型转为另一个类型
      
integer.doubleValue()

   4. 将字符串转化为数字
      
Integer.parseInt("100")

   5. 将数字转化为字符串
      
Integer.toString(100)

   6. 等等
3. 其他特别重要的功能:可以实现字符串和基本数据类型的相互转换

• 自动拆装箱

public class TestWrapper {
    public static void main(String[] args) {
        //创建基本类型
        int a=10;
        //创建包装类
        Integer Ia=new Integer(10);
        //自动拆箱和装箱
        //自动装箱:将基本类型自动转换为包装类
        Integer Ib=a;//默认内部调用:Integer.valueOf(a)
        //自动拆箱:将包装类自动转换为基本类型
        int b=Ib;//默认内部调用:Ib.intValue()
    }
}

		int ic=10;
        Integer Ic=10;
        //只要涉及到+,-,*,/,==等比较计算运算符并且有一方是基本类型,那么就会自动拆箱
        //true
        System.out.println(ic==Ic);
        //true
        System.out.println(Ic.equals(ic));//这里ic会自动装箱成Integer类进行比较

        Integer Id1=1000;
        Integer Id2=1000;
        //false
        System.out.println(Id1==Id2);//两个对象比较,比较的是地址,比较对象要用equals来比较
        //true
        System.out.println(Id1.equals(Id2));

        Integer Ie1=50;
        Integer Ie2=50;
        // 自动装箱时,当装入的数在-128~127之间时不会自动生成对象,而是将内部定义好的对象分配给这个变量
        //当两个包装类型的变量初始化的时候初始值一样,那么两个对象的地址是一样的
        // true
        System.out.println(Ie1==Ie2);
        
        Integer If=75;
        Ie1+=25;
        //而后如果改变了这个值,那他的地址也会相应改变
        //true
        System.out.println(Ie1==If);

2、String类

String类、StringBuilder类、StringBuffer类是三个字符串相关类。String类的对象代表不可变的字符序列,StringBuilder类和StringBuffer类代表可变字符序列

import java.io.UnsupportedEncodingException;
import java.util.Arrays;
import java.util.UUID;

public class TestString {
    public static void main(String[] args) throws UnsupportedEncodingException {
        String test="testString";//存放在常量区
        String test1="testString";//这两个的地址是一样的,并没有重新生成一个字符串
        //下面就会重新生成
        String test2= new String("testString");//放在堆区
        String test3= new String("testString");//这两个是两个单独的字符串

        System.out.println(test.length());//返回字符串长度,不带结束符
        System.out.println(test.isEmpty());//判断字符串是否为空//false
        System.out.println(test.startsWith("te"));//判断字符串以XX开头
        System.out.println(test.endsWith("ing"));//判断字符串以XX结尾
        System.out.println(test.toUpperCase());//将字符串英文全部改为大写并返回 ,不改变原有的值
        System.out.println(test.toLowerCase());//将字符串英文全部改为小写并返回

        System.out.println(test.charAt(1));//获得字符串的第1个字符e;java的数是从0开始的

        System.out.println(test.indexOf("S"));//查找字符串第一次出现的位置
        System.out.println(test.indexOf("S",2));//从指定位置查找字符串第一次出现的位置
        System.out.println(test.lastIndexOf("S"));//从后往前查找字符串第一次出现的位置

        System.out.println(test.substring(2));//从指定位置截取字符串
        System.out.println(test.substring(2,5));//截取中间某处的字符串

        String id=UUID.randomUUID().toString();//生成随机ID
        String file = "1.2.3.4.jpg";
        System.out.println(id+file.substring(file.lastIndexOf('.')));//截取并生成新的文件名

        System.out.println("---------------字符串转化方法------------------------");
        String test4 = "zhong国";
        byte[] bytes = test4.getBytes();//将字符串转化为字节
        //将字符串转化为字节后再转换字符编码,各平台支持的中文编码可能不一样,所以要进行转换
        System.out.println(new String(bytes,"GBK"));
        System.out.println(new String(test4.getBytes(),"UTF_16"));//给指定字符串重新编码

        System.out.println("---------------字符串拼接、替换、是否含有    ------------------------");
        String test5 = "a-b--cd-da";
        System.out.println(test5.contains("c"));//查看是否含有指定字符串
        System.out.println(test5.concat("cd"));//拼接字符串到结尾

        System.out.println(test5.replace('c','神'));//替换指定字符为指定字符

        String[] split = test5.split("-");//按指定字符串分割字符串
        System.out.println(Arrays.toString(split));

        String test6 = " a b v  ";
        System.out.println(test6.trim());//去字符串开头和结尾的空格

        System.out.println("---------------字符串比较 ------------------------");
        String test7="test";
        String test8="Test";
        System.out.println(test7.equals(test8));//判断字符串是否相等
        System.out.println(test7.compareTo(test8));//判断字符串是否相等,区分大小写
        System.out.println(test7.compareToIgnoreCase(test8));//判断字符串是否相等;不区分大小写
    }
}

3、StringBuffer和StringBuilder类

StringBuffer和StringBuilder类非常相似,均代表可变的字符序列,两个类都是抽象类AbstractStringBuilder的子类,方法几乎一模一样

两个类的区别主要是:

– StringBuffer JDK1.0提供的类,线程安全,做线程同步检查,效率较低

– StringBuilder JDK1.5提供的类,线程不安全,不做线程同步检查,因此效率较高,建议使用

//测试String,StringBuilder,StringBuilder的执行速度
public class TestSpeed {
    public static void main(String[] args) {
        String s1="";
        StringBuilder s2 = new StringBuilder();
        StringBuffer s3 = new StringBuffer();

        long l = System.currentTimeMillis();//获取系统时间
        for (int i = 0; i < 100000; i++) {//这个是十万次;String实在太慢了还浪费内存,设多了电脑跑不过来
            s1=s1.concat("拼接");
        }
        long l1 = System.currentTimeMillis();
        System.out.println("String用时:"+(l1-l));

         l = System.currentTimeMillis();
        for (int i = 0; i < 1000000; i++) {//下面两个是一百万次
            s2.append("拼接");
        }
         l1 = System.currentTimeMillis();
        System.out.println("StringBuilder用时:"+(l1-l));

        l = System.currentTimeMillis();
        for (int i = 0; i < 1000000; i++) {
            s3.append("拼接");
        }
        l1 = System.currentTimeMillis();
        System.out.println("StringBuffer用时:"+(l1-l));
    }
}

StringBuilder方法使用

public class TestStringBuilder {
    public static void main(String[] args) {
        StringBuilder builder = new StringBuilder("Test");
        System.out.println(builder);

        System.out.println(builder.append("builder"));//可以拼接几乎所有能看到的东西,并返回自身

        System.out.println(builder.insert(5, "String"));//在指定位置追加字符串
        System.out.println(builder.append(new Text()));//拼接啥玩意都能放进去

        System.out.println(builder.charAt(2));//获取指定字符
        builder.setCharAt(2,'神');//设置某个字符
        System.out.println(builder);
        builder.deleteCharAt(2);//删除指定的字符
        System.out.println(builder);

        System.out.println(builder.replace(20,30,"飘柔就是你油"));//替换指定位置的字符串
        System.out.println(builder.delete(20,30));//删除这个区间里的字符串

        System.out.println(builder.reverse());//倒转串

        String string = builder.toString();//StringBuilder转String
        System.out.println(string);
        StringBuilder builder1 = new StringBuilder(string);//String转StringBuilder
        System.out.println(builder1);


    }
}
class Text{
    StringBuilder builder = new StringBuilder("Test");
    Text(){

    }
}

StringBuilder扩容机制:

• 默认长度是16,如果传入参数则字符串的长度+16
• 在数组的长度没有装满时不会扩容
• 字符串达到最大长度后会重新创建一个:(原来最大长度<<1)+2的长度的新数组,并将原来的数据拷贝到新数组里

public class TestStringBuilder2 {
    public static void main(String[] args) {
        StringBuilder builder = new StringBuilder("Test");
        System.out.println(builder.length());
        System.out.println(builder.capacity());//底层数组长度默认为16+传进去的字符串长度
        for (int i = 0; i < 16; i++) {
            builder.append('a');
        }
        System.out.println(builder.capacity());//在数组没装满之前数组长度不变
        builder.append("123456");
        System.out.println(builder.capacity());//在长度超出之后,数组会扩容到原来的2倍+2的长度
    }
}

面试题

public class TestStringBuilder3 {
    public static void main(String[] args) {
        String a="a";
        String b="b";
        String c="c";
        String d="d";
        String str= "abcd";
        //字符串拼接如果都是常量那么就和直接写一个整体效果是一样的
        String str1="a"+"b"+"c"+"d";//创建了1个对象String
        String str2=a+b+c+d;//创建了1个对象StringBuilder
        /*上面的一行代码在虚拟机优化时会变成下面这一堆
        只要含有连续的字符串拼接就会这样优化
        StringBuilder builder = new StringBuilder();
        builder.append(a);
        builder.append(b);
        builder.append(c);
        builder.append(d);
        str2= builder.toString();
        */

        System.out.println(str==str1);//true
        System.out.println(str1==str2);//false

    }
}

4、Date类和DateFormat类

1、Date类

import java.util.Date;
//日期类
public class TestDate {
    public static void main(String[] args) {
        Date date = new Date();
        System.out.println(date);
        System.out.println(date.getTime());//获取1970年到现在的毫秒数
        System.out.println(date.toLocaleString());//获取当前时间的字符串

        System.out.println("*************************************************************");
        /**
         * Date的三个子类
         * sql包下的类
         * Date 只含有年月日
         * Time 只含有时分秒
         * Timestamp    时间戳;及含有年月日也含有时分秒
         *
         */
        java.sql.Date date1 = new java.sql.Date(System.currentTimeMillis());
        System.out.println(date1);//只有年月日
        String t="2019-8-20";
        java.sql.Date date2 = java.sql.Date.valueOf(t);//将字符串转化为日期
        System.out.println(date2);

    }
}

2、DateFormat类

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * DateFormat   格式化日期类
 *
 */
public class TestDateFormat {
    public static void main(String[] args) throws ParseException {
        Date date = new Date();
        System.out.println(date);
        //创建格式化日期格式为:"yyyy-MM-dd hh:mm:ss";因为DateFormat是一个抽象类不能new对象,所以new一个他的子类;这叫多态
        DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        String format = dateFormat.format(date);//格式化这个日期类,返回String字符串
        System.out.println(format);//2022-05-16 10:03:29

        String timer = "2010-12-10 9:15:29";//这个日期格式一定要和上面注册的格式一样"yyyy-MM-dd hh:mm:ss"
        Date parse = dateFormat.parse(timer);//将字符串日期转换成日期类;会抛出一个异常
        System.out.println(parse);
    }
}

5、Calender类日期类

import java.util.*;

/**
 * Calendar 日历类
 */
public class TestCalendar {
    public static void main(String[] args) {
        //Calendar这也是一个抽象类,需要new他的子类
        Calendar calendar = new GregorianCalendar();
        System.out.println(calendar);
        System.out.println(calendar.get(Calendar.YEAR));//获取年月日
        System.out.println(calendar.get(Calendar.MARCH));//月是从0开始的
        System.out.println(calendar.get(Calendar.DATE));

        System.out.println(calendar.getActualMaximum(Calendar.DATE));//获取当前月最大天数

        //日期类和日历类相互转化
        Date time = calendar.getTime();//日历类转日期类
        Calendar calendar1 = new GregorianCalendar();
        calendar1.setTime(time);//日期类转日历类
    }
}

6、JDK8的日期类

针对JDK8以前的日期类设计不足,比如不支持时区,线程不安全等,JDK8引入了java.time包来作为新的日期处理类

7、Math类和Random类

Math类,数学类

public class TestMath {
    public static void main(String[] args) {
        System.out.println(Math.max(10,2));//获得最大值
        System.out.println(Math.min(10, 5));//获得最小值
        System.out.println(Math.abs(-20));//获得绝对值
        System.out.println(Math.random());//生成0-1的随机数
    }
}

Random类,随机数类

Math类中虽然为我们提供了产生随机数的方法Math.random0,但是通常我们需要的随机数范围并不是[0, 1)之间的double类型的数据，这就需要对其进行- -些复杂的运算。如果使用Math.random0计算过于复杂的话，我们可以使用例外-种方式得到随机数,即Random类,这个类是专门用来生成随机数的,并且Math.random(底层调用的就是Random的nextDouble0方法。

import java.util.Random;
public class TestRandom {
    public static void main(String[] args) {
        Random random = new Random();
        System.out.println(random.nextInt(100));//获取100以内的随机整数
        System.out.println(random.nextFloat());//获取浮点随机
    }
}

8、枚举

所有的枚举类型隐性地继承自java.lang.Enum. 枚举实质上还是类!而每个被枚举的成员实质就是一个枚举类型的实例，他们默认都是public static final 修饰的。可以直接通过枚举类型名使用它们。

• 注意:
  • 
    强烈建议当你需要定义 -组常量时，使用枚举类型;
    
  • 
    另外尽量不要 使用枚举的高级特性
    

public class TestEnum {
    public static void main(String[] args) {
        //枚举就是用来表示有限个数的定值,不能输入别的参数时使用,限制用户输入数据
        TestAddPerson person = new TestAddPerson("张三", Gender.女);
        System.out.println(person);
    }
}
class TestAddPerson{
    String name ;
    Gender gender;

    public TestAddPerson(String name, Gender gender) {
        this.name = name;
        this.gender = gender;
    }

    public TestAddPerson() {
    }

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

    public String getName() {
        return name;
    }

    public Gender getGender() {
        return gender;
    }
}

枚举类

public enum Gender {
    男,女
}