Java基础——String类、StringBuffer、Integer

String概述

凡是带”“的都是String的实例对象。

String s1 = "abc";

s1是一个类类型变量，“abc”是一个对象。
字符串的最大特点就是，一旦被初始化就不可以被改变。
那么：

String s1 = "abc";
s1 = "kk";

这时候打印s1的值是kk;
这是为什么呢？不是说字符串一初始化就不能改变的吗？

对，不能改变，abc没有变，被赋值为kk之后abc还在内存中，变了的是s1，s1的引用由abc变为了kk。

定义字符串有两种方法：

String s1 = new String("abc");
String s2 = "abc";

System.out.println(s1==s2);//false
System.out.println(s1.equals(s2));//true

实验结果为false 和true 这是为什么呢？

因为“==”符号判断的是hash值，也就是说比较的是数据在内存中的存放地址。
在Object类中定义的equals方法里边调用的也是“==”（比较地址值）
但是String类复写了Object的equals方法，所以String类中调用的equals方法比较的是字符串的值。所以出现结果为真的现象。

那么在以上的s1和s2有什么区别呢？

s1在内存中有两个对象。（abc,s1）
s2在内存中有一个对象。(abc)

(字符串在内存中有一个常量池，里边是一个数组，当要新建一个abc字符串的时候，在数组中存入[a][b][c],如果要新建一个def字符串的时候，在数组中存入[d][e][f]，如果这时候要创建一个新的字符串abf，就不会再数组中重新存储数据，而是将之前存入的[a][b][f]重新组成一个字符串作为引用。)

String s = “abc”;
这句话会在常量池中寻找有没有abc这样的字符串，有的话，直接引用过来，没有的话在常量池中新建一个abc，再建立引用。

String s = new String (“abc”);
这句话指明了，我要新（new）的，我不要旧的，所以就不会在常量池中寻找，直接新建了一个字符串。

实例：

public class StringMethodDemo {
    public static void main(String[] args) 
    {
        String s1 = "abc";
        String s2 = new String("abc");
        String s3 = "abc";

        System.out.println(s1==s2);
        System.out.println(s1==s3);
    }
}

运行结果：

String类中的常见功能

String类是用于描述字符串事物的，那么他就提供了多个方法对字符串进行操作

常见的操作有：

1，获取。

字符串中的包含的字符数，也就是字符串的长度。
1. int length();获取长度
根据位置获取位置上的某个字符：
1. char charAt(int index)
根据字符获取该字符在字符串中的位置。
1. int indexOf(int ch);返回的是ch在字符串中第一次出现的位置。
2. int indexOf(int ch,int fromIndex);从fromIndex指定位置开始，获取ch在字符串中出现的位置。
3. int indexOf(String str );返回的是str在字符串中第一次出现的位置。
4. int indexOf(String str,int fromIndex);从fromIndex指定位置开始，获取str在字符串中出现的位置。

public class StringMethodDemo {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void method_get()
    {
        String s = "abcdefabc";
        //获取长度：
        sop(s.length());

        //获取指定角标下的字符
        sop(s.charAt(4));

        //获取指定元素第一次出现的位置
        sop(s.indexOf('a'));

        //获取指定元素从指定位置开始在字符串中第一次出现的位置。
        sop(s.indexOf('a',4));

        //获取指定字符串在字符串中第一次出现的位置
        sop(s.indexOf("a"));

        //获取指定字符串从指定位置开始在字符串中第一次出现的位置。
        sop(s.indexOf("a",4));

        //从后往前找指定字符在字符串中第一次出现的位置
        sop(s.lastIndexOf("a"));
    }
    public static void main(String[] args) 
    {
        method_get();
    }
}

运行结果是：

2，判断：

字符串中是否包含某一个子串
1. boolean contains(str)
2. 特殊之处：indexOf（str）可以索引str第一次出现的位置，如果返回-1，表示该str不在字符串中存在。所以，也可以用于对指定判断是否包含。if(str.indexOf("aa")!=-1)
3. 而且该方法既可以判断，又可以获取出现的位置。
字符串中是否有内容
1. boolean isEmpty();原理就是判断长度是否为0
字符串是否是以指定内容开头
1. boolean startsWith(str);
字符串是否是以指定内容结尾
1. boolean endsWith(str);
判断字符串内容是否相同，复写了Object类中的equals方法。
1. boolean equals(str);
判断内容是否相同，并忽略大小写。
1. boolean equalsIgnoreCase();

public class StringMethodDemo {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void method_is()
    {
        String str = "ArrayDemo.java";
        //判断是否是以“Array”开头的
        sop(str.startsWith("Array"));

        //判断中间是否包含“Demo”
        sop(str.contains("Demo"));

        //判断是否是以“.java”结尾的
        sop(str.endsWith(".java"));

        //判断字符串是否相同
        sop(str.equals("arraydemo.java"));

        //忽略大小写判断字符串是否相同
        sop(str.equalsIgnoreCase("arraydemo.java"));
    }
    public static void main(String[] args) 
    {
        method_is();
    }
}

运行结果为：

3，转换；

将字符数组转换成字符串
1. 构造函数：
  1. String(char[]):将字符数组转换成字符串
  2. String(char[],offset,count);将字符数组的一部分转换成字符串，参数依次为：字符数组，起始位置的角标，一共要转换成字符串的个数。
2. 静态方法：
  1. static String copyValueOf(char[]);
  2. static String copyValueOf(char[] data,int offset,int count);
  3. static String valueOf(char[]);
将字符串转成字符数组
1. char[] toCharArray();
将字节数组转换成为字符串
1. String(byte[])
2. String(byte[],offset,count)；将字节数组中的一部分转成字符串
将字符串转成字节数组：
1. byte[] getBytes();
将基本数据类型转换成字符串
1. static String valueOf(int);
2. static String valueOf(double);
3. //3+”“和String.valueOf(3);没什么区别
特殊：字符串和字节数组在转换过程中，是可以指定编码表的。

示例：

public class StringMethodDemo {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void method_trans()
    {
        //字符数组转换成字符串
        char[] chs ={'a','b','c','d','e','f','g'};
        String str = new String(chs);
        String str1 = new String(chs,1,4);
        sop("str="+str);
        sop("str1="+str1);

        //将字符串转成字符数组：
        char[] arr = str.toCharArray();
        for (int x =0;x<arr.length ;x++ )
        {
            sop("char["+x+"]="+arr[x]);
        }

        //将字符串转换成字节数组
        byte[] bts = str.getBytes();
        for (int x = 0;x<bts.length ;x++ )
        {
            sop("bts["+x+"]="+bts[x]);
        }
    }
    public static void main(String[] args) 
    {
        method_trans();
    }
}

运行结果：

4，替换

String replace(oldchar,newchar);将字符串中的匀速进行替换

示例：

public class StringMethodDemo {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    //替换方法 String replace(oldchar,newchar);
    public static void method_replace()
    {
        String s1 = "hello java";
        String s2 = s1.replace("a","n");//可以单个字符进行调换
        String s3 = s1.replace("java","world");//也可以将指定的字符串进行调换
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
    }
    public static void main(String[] args) 
    {
        method_replace();
    }
}

运行结果：

需要注意的是，替换之后的字符串在内存中还存在，因为字符串只要一被创建就不会被改变。

5，切割

String [] split(regex);

将给定字符串用指定的符号切割出来，显然返回来的是一个字符串数组

示例：

public class StringMethodDemo {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    //切割方法 String[] split(regex);
    public static void method_split()
    {
        String s1 = "zhangsan,lisi,wangwu";
        String[] arr=s1.split(","); //里边指定切割的参照符号，用“”括起来
        for (int x =0;x<arr.length ;x++ )//用循环遍历打印出切割出来的字符串
        {
            System.out.println("String["+x+"]=="+arr[x]);
        }
    }
    public static void main(String[] args) 
    {
        method_split();
    }
}

运行结果：

6，子串，获取字符串中的一部分

String substring(begin);从指定位置开始到结尾
String substring(begin,end);包含头不包含尾

public class StringMethodDemo {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    //获取子串，substring(start,end)//substring(start)
    public static void method_substring()
    {
        String s1 = "nihaowojiaoheshuaishuai";
        String s2 = s1.substring(5);
        //获取从5角标开始到字符串结束中间的字符串
        String s3 = s1.substring(0,s1.length());
        //获取从0角标开始，到字符串结束中间的字符串。（包含头不包含尾）

        sop(s1);
        sop(s2);
        sop(s3);
    }
    public static void main(String[] args) 
    {
        method_substring();
    }
}

运行结果：

7，转换，去除空格，比较

将字符串转成大写或者小写
1. String toUpperCase();
2. String toLowerCase();
将字符串两端的多个空格去除
1. String trim();
对两个字符串进行自然顺序的比较
1. int compareTo(String);

public class StringMethodDemo {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    //转换，去空格，比较
    public static void method()
    {
        //转换。转换字符串的大小写
        String s1 = "      Hello Java      ";
        String s2 = s1.toUpperCase();//将所有字符转换为大写形式
        String s3 = s1.toLowerCase();//将所有字符抓换成小写形式

        sop(s1);
        sop(s2);
        sop(s3);

        //去除字符串两端的空格：
        String s4 = s1.trim();
        sop(s4);

        //比较（按照字典顺序比较两个字符串的大小，实际上就是按照ASCII值比较的）
        String s5 = "abc";
        String s6 = "acd";
        int x = s5.compareTo(s6);
        //如果s5比s6小，则会返回一个<0的值，如果s5比s6大，则会返回一个>0的数，
        //至于返回的是多少：在以上字符串中，先比较a相同，再比较第二位，s5第二位是b,s6第二位是c,所以b-c=-1(比较ASCII码值)
        sop(x);
    }
    public static void main(String[] args) 
    {
        method();
    }
}

运行结果：

练习：模拟trim方法的代码

//需求：写一个模拟trim方法的代码。将字符串两端的空格去除

/*
思路，取字符串开始的角标为指针，判断是不是空格，如果是空格，指针++
        从后往前数也一样的道理
        然后把指针中间的字符串取出来就行了
        需要注意的是，两个指针一个往后走，一个往前走，不能跑的错开了。
*/

public class MyTrim {
    public static void main(String[] args) 
    {
        String s = "     ni hao     ";
        String s1 = mytrim(s);
        sop(s);
        sop(s1);
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static String mytrim(String s)//定义自己的去空格方法
    {

        int pos_start = 0,pos_end = s.length()-1;//定义连个指针 ，分别在开头和结尾处
        while (s.charAt(pos_start)==' ' && pos_start<pos_end)//判断指针所在的位置的字符是不是空格，是则指针再往前走
        {
            pos_start++;
        }
        while (s.charAt(pos_end)==' ' && pos_start<pos_end)
        {
            pos_end--;
        }
        return s.substring(pos_start,pos_end+1);//返回两个指针中间的字符串，记住获取子串包含头不包含尾。
    }
}

运行结果：

练习二：定义方法将字符串进行反转。

//需求：将一个字符串进行反转
/*
思路：
先把字符串转换成字符数组，
将字符数组进行反转
再把字符数组变成字符串
*/

public class ReverseStringDemo {
    public static void sop(Object obj)//为了方便定义的打印方法
    {
        System.out.println(obj);
    }
    public static String reverseString(String s)//反转字符串的方法
    {
        return reverseString(s,0,s.length());//返回反转后的整个字符串。（包含头不包含尾）
    }
    private static void reverse(char[] chs,int x,int y)//反转数组的方法
    {
        //定义两个指针，一前一后，循环一次，自增（减）一次，
        for (int start = x,end = y-1;start<end ;start++,end-- )
        {
            swap(chs,start,end);//每循环一次，将前后两个指针的数据调换位置
        }
    }
    private static void swap(char[] arr,int x,int y)//调换位置的方法
    {
        char temp = arr[x];
        arr[x] = arr[y];
        arr[y] = temp;
    }
    //为了提高方法的扩展性，这里给定不同的参数进行函数的重载。
    //将字符串中的指定位置的字符串进行反转。
    public static String reverseString(String s,int start,int end)
    {
        char[] chs = s.toCharArray();//先将字符串变成字符数组
        reverse(chs,start,end);//反转数组
        return new String(chs);//将字符数组变成字符串并返回
    }
    public static void main(String[] args) 
    {
        String s = "    ab cd    ";
        //给定一个字符串
        sop("("+s+")");//打印原字符串
        sop("("+reverseString(s)+")");//将整个字符串反转
        sop("("+reverseString(s,4,9)+")");//将字符串中的指定序列的字符串反转
    }
}

运行结果为：

练习三：获取一段字符串在另一段字符串中出现的次数

//获取一个字符串在另一个字符串中出现的次数
/*
思路：先要有一个计数器
需要用到indexOf，所以就需要有每次开始数的角标
然后每见到一次key的值，计数器加1
*/

public class KeyStringCount {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static int function(String str,String key)//给两个参数，一个是字符串，一个是要寻找的子串
    {
        int count = 0;//计数器
        int index = 0;//开始查找的位置（角标）
        while ((index = str.indexOf(key,index))!=-1)//当找到第一个匹配的时候，将找到的角标值加key的长度，作为下次开始找的角标值
        {
            index = index+key.length();
            count++;
        }
        return count;
    }
    public static void main(String[] args) 
    {
        String s = "abqqcdqqefqqghqqijqqk";//5个qq
        sop("count===="+function(s,"qq"));
    }
}

运行结果：

练习四：获取两个字符串中的最大相同子串

//需求：获取两个字符串中的最大相同子串
/*
思路：按短的那个字符串先找，找到了，就中了
找不到，就字符串长度减1，找一次，然后两边角标自增，再找一次，
找不到，就字符串长度减2，角标自增，一共找三次。
如果找到了，就把找到的那个切出来
*/

public class GetMaxSubString {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static String getMaxSubString(String s1,String s2)
    {
        //因为不确定传进来的字符串参数哪个更长，所以先将长短区分出来，分别引用给Max和min
        String max,min;
        max = (s1.length()>s2.length())?s1:s2;//三目运算符，s1的长度大于s2吗，如果大于，将s1的值引用给max
        min = (max == s1)?s2:s1;

        //经过分析，判断最大相同子串要把短字符串每次去一位然后角标自增的方式，
        /*
                           长度                    判断次数
            第一次判断：0-min.length()-0            1
            第二次判断：0-min.length()-1            2
            第三次判断：0-min.length()-2            3
            第四次判断：0-min.length()-3            4

        */
        for (int x = 0;x<min.length() ;x++ )//第一个for控制外层循环（判断）次数的
        {
            for (int y = 0,z = min.length()-x;z!=min.length()+1 ;y++,z++ )//第二个for用来控制内层循环判断次数的
            {
                String temp = min.substring(y,z);//每次循环都把判断过的子串取出来
                if (max.contains(temp))//判断长字符串中是不是有该子串，
                    return temp;//有的话就返回该字符串。
            }
        }
        return "";
    }
    public static void main(String[] args) 
    {
        String s1 = "jfdlagehellorkajfalfd";
        String s2 = "djkdhellodof";
        sop(getMaxSubString(s2,s1));
    }
}

运行结果：

根据老师写的代码，下面是自己写的代码，同样可以实现这样的功能：

//需求：获取两个字符串中的最大相同子串
/*
    写完后发现老师的代码在for循环的那一段不太好理解，
    然后根据自己的想法，写了一段，可以运行
    代码不分家，只要能实现功能就好
*/

public class GetMaxSubString2 {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static String getMaxSubString(String s1,String s2)
    {

        String max,min;
        max = (s1.length()>s2.length())?s1:s2;
        min = (max == s1)?s2:s1;

        //经过分析，判断最大相同子串要把短字符串每次去一位然后角标自增的方式，
        /*
                           长度                    判断次数
            第一次判断：0-min.length()-0            1
            第二次判断：0-min.length()-1            2
            第三次判断：0-min.length()-2            3
            第四次判断：0-min.length()-3            4

        */
        for (int x = min.length();x>-1 ;x-- )//第一个for控制字符串长度的
        {
            for (int y = 0,z = x;z!=min.length()+1 ;y++,z++ )//第二个for用来控制内层循环判断次数的
            {
                String temp = min.substring(y,z);
                if (max.contains(temp))
                    return temp;
            }
        }
        return "";
    }
    public static void main(String[] args) 
    {
        String s1 = "jfdlagehellorkajfalfd";
        String s2 = "djkdhellodof";
        sop(getMaxSubString(s2,s1));
    }
}

运行结果和上图相同。

StringBuffer

StringBuffer是字符串缓冲区，可以用于对字符串进行修改的

是一个容器。
特点：
1 长度是可变化的。
2 可以直接操作多个数据类型
3 最终会通过toString方法变成字符串。

C ： create U ： update R ： read D： delete

面盆理论：StringBuffer就是一个面盆，在里边加各种东西，完了返回来的还是这个面盆，同一个面盆，没有任何的改变，

public class StringBufferDemo {
    public static void main(String[] args) 
    {
        StringBuffer sb = new StringBuffer();
        StringBuffer sb1 = new StringBuffer();//新new了一个，不一样
        StringBuffer sb2 = sb.append(345);//经过操作返回来的一个，还是原来的面盆
        sop(sb==sb1);//false
        sop(sb==sb2);//true
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

1，存储。
StringBuffer append();将指定数据作为参数添加到已有数据的结尾处。
StringBuffer insert（Index，数据）可以将数据插入到指定位置。

class StringBufferDemo
{
    public static void main(String[] args)
    {
        StringBuffer sb = new StringBuffer();//定义一个字符串容器
        sb.append("abc").append(true).append(34);//在里边数据的末尾处先后添加各种类型的数据
        sop(sb.toString());//abctrue34
        sb.insert(1,"qq");//在1角标位置处添加qq字符串
        sop(sb.toString());//aqqbctrue34
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

2，删除
StringBuffer delete（start，end）删除缓冲区中的数据，包含头不包含尾
StringBuffer deleteCharAt()删除指定位置的字符。

//字符串缓冲区的删除方法演示

public class StringBufferDelete {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void stringBufferDelete()
    {
        StringBuffer sb = new StringBuffer("abcdefghijk");
        sop(sb.toString());
        sb.delete(2,6);//将指定范围内的字符串删除
        sop(sb.toString());//abghijk

        sb.deleteCharAt(0);//删除指定位置的字符
        sop(sb.toString());//bghijk

        sb.delete(0,sb.length());//清空缓冲区
        sop(sb.toString()+";");

    }
    public static void main(String[] args) 
    {
        stringBufferDelete();
    }
}

运行结果：

3，获取。
char charAt（Index）获取一个
int indexOf(String str);获取指定字符串出现的角标
int laseIndexOf(String str);倒序查找指定字符串出现的角标
int length() 获取容器里边字符串的长度
String subString(int start,int end)切出来的字符串

这里和Sting类中的方法一样的，，就不演示了。

4，修改
StringBuffer replace（start，end，string）；修改区间内的一整片
void setCharAt（int Index，char ch）;将指定位置的元素换成指定的字符。

//演示字符串缓冲区中的修改元素的方法

public class StringBufferReplace {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void stringBufferReplace()
    {
        StringBuffer sb = new StringBuffer("hello  world");
        sop(sb.toString());
        sb.replace(7,12,"java");//将sb中的元素，从角标7到角标12中的元素，替换成java
        sop(sb.toString());

        sb.setCharAt(7,'J');//将hello java中的第7的元素换成J
        sop(sb.toString());
    }
    public static void main(String[] args) 
    {
        stringBufferReplace();
    }
}

运行结果：

5，反转
StringBuffer reverse（）反转容器中的字符串
示例：


//演示字符串缓冲区的反转元素的方法
public class StringBufferReverse {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void stringBufferReverse()
    {
        StringBuffer sb = new StringBuffer("abcdefghijk");
        sop(sb.toString());//打印原字符串缓冲区中的字符串
        sb = sb.reverse();//将容器中的字符串反转
        sop(sb.toString());//打印反转后的字符串
    }
    public static void main(String[] args) 
    {
        stringBufferReverse();
    }
}

运行结果：

6，将字符串缓冲区中的元素转移到指定数组中
void getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin);

StringBuffer sb = new StringBuffer();
sb.append("abcdef");
char[] chs = new char[4];
sb.getChars(1,4,chs,3);//将sb中从角标1到角标4的元素转给chs数组，在数组中从1角标开始依次插入
for(int x = 0;x<chs.length;x++)
{
    System.out.println("chs["+x+"]="+chs[x]+";");
}

运行结果：

在jdk1.5之后出现了StringBuilder。

StringBuffer是线程同步的。
StringBuilder是线程不同步的。
以后开发建议使用StingBuilder

升级三个因素

提高效率
简化书写
提高安全性

基本数据类型对象包装类

根据面向对象的原则，Java中将所有的东西都进行了包装，包括基本数据类型

那么将基本数据类型封装成对象有什么用呢？
看下边的一个例子：

//基本数据类型的对象包装类

public class IntegerDemo {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args) 
    {
        //假如我们想知道int类型的数值的最大值
        sop(Integer.MAX_VALUE);

        //相同的道理，int类型的数值的最小值
        sop(Integer.MIN_VALUE);

    }
}

实验结果：

这并不是基本数据类型对象的最常见的作用，

最常见的作用就是：基本数据类型和字符串类型之间做转换，

基本数据类型转换成字符串：

基本数据类型+”“;
基本数据类型.toString(基本数据类型值);
如：Integer.toString(34);//将34整数变成“34”。

字符串转基本数据类型的操作：

//基本数据类型的对象包装类

public class IntegerDemo {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args) 
    {
    //将一个字符串转成整数

        int num = Integer.parseInt("123");
        sop("num = "+(num+4));//127
    }
}

int a = Integer.parseInt(“123”);字符串中必须全是int类型的值，否则就是数字格式异常,这个事静态调用方式。

Integer i = new Integer(“123”);
int num = i.intValue();//这个是对象调用方式

其他类型道理也一样的

double b = Double.parseDouble(“12.23”);
boolean b = Boolean.parseBoolean(“true”);

十进制转成其他进制数

Integer.toBinaryString(6);//110
Integer.toOctalString(100);//144
Integer.toHexString(60);//3c

其他进制转换成十进制

parseInt("110",2);//6
parseInt("144",8);//100
parseInt("3c",16);//60

jdk1.5以后的新特性：

看一串代码：

//jdk1.5以后的新特性

public class IntegerDemo {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args) 
    {

        Integer a = new Integer("123");
        Integer b = new Integer(123);

        sop("a==b:"+(a==b));
        sop("a.equals(b):"+a.equals(b));
    }
}

运行结果为：

出现这样的结果是为什么呢？
a==b为假，正常，因为都是新new的对象，地址值肯定不一样
a.equals(b)是因为他和字符串一样比较的是值。所以结果为真

再有一个示例：

//jdk1.5以后的新特性

public class IntegerDemo {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args) 
    {

        Integer i = 4;//怎么可以直接将数字赋值给对象？在这里4是一个对象，因为Integer是一个类，i就是一个对象了，i指向的一定是对象。
                    //在这里，4会进行自动装箱，也就是会自动将4封装成对象，赋值给i（new Integer(4)）
                    //在这里，Integer还可以赋值为null（新特征），编译不会出错，就是运算的时候会出现空指针异常


        i = i+2;    //新特性：i是一个对象，2是一个数字，两个不同类型的东西怎么能相加？
                    //可以,在这里进行运算的时候，i会进行自动的拆箱，i.intValue();转换成int类型的值再进行运算
                    //计算完结果之后再将结果自动装箱，封装成对象，赋值给i
    }
}

新特征3：

//jdk1.5以后的新特性

public class IntegerDemo {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args) 
    {
        Integer a = 128;
        Integer b = 128;
        sop("a==b:"+(a==b));


        Integer c = 127;
        Integer d = 127;
        sop("c==d:"+(c==d));
    }
}

运行结果：

为什么会出现这样的结果呢？

定义abcd的过程可以看成是：Integer a = new Integer(128);
abcd都是不同的对象，但是，区别在于赋给的数值不一样，

新特征3：对于byte范围内的值，如果该数值已经存在，则不会开辟新的空间，所以说c和d指向了同一个对象。（byte范围-128~127）

Java基础——String类、StringBuffer、Integer

String概述

String类中的常见功能

StringBuffer

基本数据类型对象包装类

杭州的 IT 崩盘了么？

VS2022 解决方案打不开 .NET Framework 4.0 、 4.5 等老项目

Vue3 运行可以，build 打包发布报错，app.config.globalProperties 用法坑

Java基礎——集合框架（二）

Java基礎——String類、StringBuffer、Integer

Java基礎——包

線程之間通信、停止線程、守護線程

Java基礎——異常及處理方法

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結