java学习总结第四周

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

这周学习了

一、包装类

针对八种基本数据类型相应的引用类型——包装类

1丶包装类产生原因

Java语言是面向对象的编程语言，而基本数据类型声明的变量并不是对象，java为其提供包装类，就增强了Java面向对象的性质。
而且，如果只有基本数据类型，使用时是很不方便的，比如，在集合类中，无法将int 、double等类型放进去的，因为集合的容器要求元素是Object类型。有了包装类以后，我们就可以把基本数据类型放进去；这是我认为的两个最重要的原因。

2丶包装类分类

Java有八种基本数据类型：byte、short、int、long、float、double、boolean、char

Java为其提供了8种对应的包装类（一一对应）：Byte、Short、Integer、Long、Float、Double、Boolean、Character。

3丶自动装箱和拆箱

先说自动装箱，举个栗子：

package Baozhuang;

public class test1 {
    //自动装箱
    //int->Integer
    int n1=15;
    Integer integer=n1;//底层使用的是Integer.valueOf（）方法
    
 }

再说自动拆箱，举个栗子：

public class test1 {
    //自动装箱
    //int->Integer
    int n1=15;
    Integer integer=n1;//底层使用的是Integer.valueOf（）方法
    //自动拆箱
    int n2=integer;//ok自动拆箱就这么简单

 }

4丶String类和包装类（Integer）的相互转换

代码如下：

   //Integer->String
        Integer i=666;//自动装箱
        //方式1 +“ ”
        String str1=i+"";
        //方式2
        String str2=i.toString();
        //方式3
        String str3=String.valueOf(i);

        //String->包装类（Integer）
        String str4="12345";
        Integer integer1=Integer.parseInt(str4);//使用到自动装箱
        Integer integer2=new Integer(str4);//使用到构造器
        //以上是字符串里面是数字的情况，当字符串里面不全是数字时候，我们需要先把字符串切开转成char字符然后再转换，这个问题困扰我好久valueOf
		 String str5=“学长们真帅”;
		 char [] bb=str5.toCharArray();
		  for (char c:bb){
		 System.out.println(Integer.valueOf（c）);
		 }

5丶Integer和Character的常用方法

在下面代码中我写了几个常用的方法如下

//Integer和Character的常用方法
        System.out.println(Integer.MIN_VALUE);//返回最小值
        System.out.println(Integer.MAX_VALUE);//返回最大值

        System.out.println(Character.isDigit('a'));//判断是不是数字
        System.out.println(Character.isLetter('b'));//判断是不是字母
        System.out.println(Character.isUpperCase('a'));//判断字母是不是大写
        System.out.println(Character.isLowerCase('b'));//判断字母是不是小写

        System.out.println(Character.isWhitespace('a'));//判断是不是空格
        System.out.println(Character.toLowerCase('A'));//转换成小写
        System.out.println(Character.toUpperCase('a'));//转换成大写

    }

6丶包装类空指针异常问题

原因是null表示i没有指向任何对象的实体，但作为对象的名称是合法的（不管这个对象名称是否指向某个对象的实体），由于实际上i 并没有指向任何对象的实体，所以也就不可能操作Integer.Value（）方法，这样上面的写法会出现NullPointerException的错误

package Baozhuang;

public class test1 {
    public static void main(String[] args) {
        //空指针异常问题
        Integer i=null;
        int j=i;

    }
 }

编译时不报错但是运行时候报错如下

Exception in thread "main" java.lang.NullPointerException
	at Baozhuang.test1.main(test1.java:7)

进程已结束,退出代码1

解决方案：
针对包装类进行操作时要先判断其是否为空。

package Baozhuang;

public class test1 {
    public static void main(String[] args) {
        //空指针异常问题
        Integer i=null;
        if(i!=null){
            int j=i;
        }else{
            System.out.println("空指针！");
        }

    }
 }

运行结果

空指针！

进程已结束,退出代码0

二、String类

String类是Java中非常常见的一个类；

1丶创建字符串

两种方式

package Stringg;

public class Zifu {
    //方式一：
    String str="hello";
    //方式二：
    String str2=new String("hello");

}

2丶字符串比较相等（equals）

字符串比较不能用=，原因如下：
1、String使用==比较并不是在比较字符串的内容，而是比较两个引用是否指向一个对象。
2、Java中相比较字符串的内容必须用String类提供的equals.如下：

String str1 = new String("Hello");
String str2 = new String("Hello");
System.out.println(str1.equals(str2));
// System.out.println(str2.equals(str1)); // 或者这样写也行
// 执行结果
true

3丶字符串里面的常用方法

public boolean equals(Object obj); 判断字符串的内容是否相同，区分大小写
public boolean equalsIgnoreCase(String str); 判断字符串的内容是否相同，不区分大小写
public boolean contains(String str); 判断字符串是否包含传递的进来字符串
public boolean startswith(String str); 判断字符串是否是以传递进来的字符串开头
public boolean endswith(String str); 判断字符串是否以传递进来的字符串结尾
public boolean isEmpty(); 判断字符串的内容是否为空串
测试代码如下：

package Stringg;

public class Zifu {


    public static void main(String[] args) {
        String a="abc";
        boolean a1=a.equals("ABC");
        System.out.println(a1);
        boolean a2=a.equalsIgnoreCase("ABC");
        System.out.println(a2);
        String s="学长，最帅啦abc";
        System.out.println(s.contains("最帅啦"));
        System.out.println(s.startsWith("学"));
        System.out.println(s.endsWith("abc"));
    }

}

运行结果

false
true
true
true
true

进程已结束,退出代码0

还有一些
public int length(); 获取字符串长度
public char charAt(int index); 获取指定索引位置的字符
public int indexOf(int ch); 返回指定字符在此字符串第一次出现处的索引
public int indexOf(String str); 返回指定字符串在此字符串第一次出现处的索引
public String substring(int start); 从指定位置开始截取字符串，默认到结尾
public String substring(int start,int end); 从指定位置开始到指定位置结束截取字符串
测试代码如下

package Stringg;

public class Zifu {


    public static void main(String[] args) {
        String a="abc";
        String s="学长，最帅啦abc";
        System.out.println(a.length());// 获取字符串长度
        System.out.println(s.charAt(4));// 返回指定字符在此字符串第一次出现处的索引
        System.out.println(a.indexOf('b'));//返回指定字符在此字符串第一次出现处的索引
        System.out.println(a.indexOf("学长"));// 返回指定字符串在此字符串第一次出现处的索引
        System.out.println(s.substring(3));// 从指定位置开始截取字符串，默认到结尾
        System.out.println(s.substring(2,4));// 从指定位置开始到指定位置结束截取字符串
    }

}

运行结果：

3
帅
1
-1
最帅啦abc
，最

进程已结束,退出代码0

还有个trim方法，可以去除字符串两端的空格，但是内部的空格不能去除；

4丶StringBuffer和StringBuilder类

StringBuffer和StringBuilder是java的两个类，他们代表可变的字符序列，可以对字符串内容进行增删。
StringBuffer和String Builder之间的唯一区别是，StringBuilder方法不同步，因为它不是线程安全的，因为两个线程可以同时调用StringBuilder方法。另一方面，字符串缓冲区是线程安全的。
他俩里面的方法基本相同，我们以StringBuffer举例子

1丶构造方法

1——StringBuffer() ：构造一个没有任何字符的StringBuffer类。
2——StringBuffer(int length) ：：构造一个没有任何字符的StringBuffer类，并且，其长度为length。
3——StringBuffer(String str) ：以str为初始值构造一个StringBuffer类。

2丶常用方法

举了以下几个栗子，包含了增删改查，已经注释出来了，代码如下

package Stringg;

public class Zifu {


    public static void main(String[] args) {
        StringBuffer sqb = new StringBuffer("sqb5211314sqb666sqbxixi");
        // 增加（在字符串末尾插入字符）
        System.out.println(sqb.append(".java"));  

        // 插入（在索引 2 的位置插入字符）
        System.out.println(sqb.insert(2,"%")); 

        // 修改（索引范围）
        System.out.println(sqb.replace(5,9,"love")); 

        // 删除单个字符
        System.out.println(sqb.deleteCharAt(0));

        // 删除多个（删除两个索引区间的值）
        System.out.println(sqb.delete(0,4));

        // 反向输出字符串
        System.out.println(sqb.reverse());

        // 输出 0-4 索引的值
        System.out.println(sqb.substring(0,4));

        // 输出从 5 索引开始的值，直到结束
        System.out.println(sqb.substring(5));
    }

}

运行结果：

sqb5211314sqb666sqbxixi.java
sq*b5211314sqb666sqbxixi.java
sq*b5China14sqb666sqbxixi.java
q*b5China14sqb666sqbxixi.java
China14sqb666sqbxixi.java
avaj.ixixbqs666bqs41anihC
avaj
ixixbqs666bqs41anihC

进程已结束,退出代码0

3丶String 和 StringBuffer 和 StringBuilder的选择

结论如下，总结自韩顺平老师课堂：
如果字符串存在大量的修改操作，一般使用 StringBuffer【多线程情况下】或 StringBuilder【单线程情况下】
如果字符串存在大量的修改，并在单线程的情况下，使用StringBuilder
如果字符串存在大量的修改，并在多线程的情况下，使用StringBuffer
如果我们字符串很少修改，被多个对象引用，使用String，比如配置文件等

三丶Math类

1丶简介

Math 类封装了常用的数学运算，提供了基本的数学操作，如指数、对数、平方根和三角函数等。Math 类位于 java.lang 包，它的构造方法是 private 的，因此我们无法创建 Math 类的对象，并且 Math 类中的所有方法都是类方法，可以直接通过类名来调用它们。

2丶两个静态常量

Math 类中包含 E 和 PI 两个静态常量，正如它们名字所暗示的，它们的值分别等于 e（自然对数）和 π（圆周率）

System.out.println("E 常量的值：" + Math.E);
System.out.println("PI 常量的值：" + Math.PI);

结果：

E 常量的值：2.718281828459045
PI 常量的值：3.141592653589793

3丶常用方法

1丶求最大值最小值和绝对值

我把他们放在一个代码里面展示：

  public static void main(String[] args) {
        System.out.println("10 和 20 的较大值：" + Math.max(10, 20));
        System.out.println("1.6 和 16 的较小值：" + Math.min(15.6, 15));
        System.out.println("-666 的绝对值：" + Math.abs(-12));
    }

结果

10 和 20 的较大值：20
1.6 和 16 的较小值：1.6
-666 的绝对值：666

进程已结束,退出代码0

2丶取整

取整有很多方式，展示四种常用的

double num = 123.123;
        System.out.println("大于或等于 "+ num +" 的最小整数：" + Math.ceil(num));//向上取整
        System.out.println("小于或等于 "+ num +" 的最大整数：" + Math.floor(num));//向下取整
        System.out.println("将 "+ num +" 加上 0.5 之后最接近的整数：" + Math.round(num));//加上 0.5 之后最接近的整数
        System.out.println("最接近 "+num+" 的整数：" + Math.rint(num));//最接近num的整数

运行结果如下

大于或等于 123.123 的最小整数：124.0
小于或等于 123.123 的最大整数：123.0
将 123.123 加上 0.5 之后最接近的整数：124
最接近 123.123 的整数：123.0

进程已结束,退出代码0

还有两个大的类型，指数运算和三角运算，平时用的太少不做赘述，方法如下

四丶Random类

1丶简介

这个类的作用是在指定的取值范围内随机产生数字，需要注意的是，
Random类中实现的随机算法是伪随机，也就是有规则的随机。在进行随机时，随机算法的起源数字称为种子数(seed)，在种子数的基础上进行一定的变换，从而产生需要的随机数字。相同种子数的Random对象，相同次数生成的随机数字是完全相同的。也就是说，两个种子数相同的Random对象，第一次生成的随机数字完全相同，第二次生成的随机数字也完全相同。这点在生成多个随机数字时需要特别注意。

2丶构造方法

有有参和无参的构造方法，代码如下

 Random r1=new Random();
        //第二种，传入种子
  Random r2=new Random(5);

第一种用nextInt的话，每次产生对象是不一样的，因为它是以当前的时间为种子的，第二种就一样了；

3丶常用方法

1.random.nextInt()

random.nextIn()的作用是随机生成一个int类型，因为int 的取值范围是 -2147483648——2147483647 ，所以生成的数也是处于这个范围
同时注意，用两种构造方法定义的random对象产生的随机数不同

  Random r1=new Random();
        //第二种，传入种子
        Random r2=new Random(5);
        //1 nextInt ,
        System.out.println(r1.nextInt());
        System.out.println(r2.nextInt());

结果

-3906573
-1157408321

进程已结束,退出代码0

2.random.nextInt(int bound)

random.nextInt(int bound)方法的作用是生成一个0-参数bound范围内的随机数，但是要记住，参数bound必须是正数，不可为负数

 public static void main(String[] args) {
        //第一种，无参构造函数
        Random r1=new Random();
        //第二种，传入种子
        Random r2=new Random(5);
        System.out.println(r1.nextInt(8));
    }

结果

5

进程已结束,退出代码0

3.random.nextLong()

random.nextLong()会随机生成一个Long类型，这个跟nextInt只是范围不一样

4.random.nextDouble()

random.nextDouble()会生成一个0-1的double类型，而不是生成double取值范围中的数

 public static void main(String[] args) {
        Random random = new Random();
        System.out.println("double:"+random.nextDouble());
    }
    结果
    double:0.5247002436674117

进程已结束,退出代码0

5.random.nextFloat()

random.nextFloat()会生成一个随机的0-1之间的浮点型，大体同double一样，不做赘述

6.random.nextBoolean()

random.nextBoolean()会生成一个true或false，概率相同，这个就不用多说了。

7.random.nextBytes(byte[] bytes)

random.nextBytes()会为一个byte类型的数组随机赋值，具体如下所示：

    public static void main(String[] args) {
        Random random = new Random();
        byte[] bytes = new byte[6];
        random.nextBytes(bytes);
        for (int i = 0; i < bytes.length; i++) {
            byte b1 = bytes[i];
            System.out.print(b1+"\n");
        }

    }

运行结果如下

79
-64
8
-114
-46
127

总结

这周总结到此结束，下周加把力！