Day13JavaSE——StringBuffer&数组常见操作&Arrays类&基本数据类型包装类
文章目录
StringBuffer&StringBuilder
概述
我们如果对字符串进行拼接操作,每次拼接,都会构建一个新的String对象,既耗时,又浪费空间。而StringBuffer就可以解决这个问题
public class Demo1 {
public static void main(String[] args) {
//我们如果对字符串进行拼接操作,每次拼接
//都会构建一个新的String对象,既耗时,又浪费空间。
String s="aaa";
String s1="bbb";
String s2="ccc";
System.out.println(s + s1 + s2);
System.out.println("==============================");
//这种拼接编译器会优化,最后只构建一个对象
String s3="aaa"+"bbb"+"ccc";
System.out.println(s3);
}
}
StringBuffer的方法
StringBuffer常用的功能
StringBuffer的添加功能
StringBuffer的添加功能
public StringBuffer append(String str):
可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身
public StringBuffer insert(int offset,String str)
在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身
public class Test {
public static void main(String[] args) {
/*往容器中添加内容,返回的还是容器本身*/
StringBuffer sb = new StringBuffer();
StringBuffer sb1=sb.append("aksjdhc;ja").append(54554).append("dwaecasdcasfv");
System.out.println(sb==sb1);
//取出容器中的内容,容器中的内容会以字符串的形式返回
//StringBuffer重写了toString()方法,把容器中的内容拼接好以字符串的形式返回
String s = sb.toString();
System.out.println(s);
//默认调用toString方法
System.out.println(sb);
}
}
public class Test {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
//append()方法往容器中添加数据,可以把任意类型添加到容器中
sb.append("rtgbsrgbs").append(01531341354).append(3.141592654).append(false);
//最后你可以调用toString方法,把容器中的数据以字符串形式返回
String s = sb.toString();
System.out.println(s);
System.out.println(sb);
}
}
public class Test2 {
public static void main(String[] args) {
/*public StringBuffer(String str):
指定字符串内容的字符串缓冲区对象
构造一个字符串缓冲区,并将其内容初始化为指定的字符串内容*/
StringBuffer sb = new StringBuffer("abc");
StringBuffer sb2 = sb.append("eeeee");
StringBuffer sb3 = sb.append("hhhh");
StringBuffer sb4 = sb.append("yyyyy");
StringBuffer sb5 = sb.append("cccc");
System.out.println(sb.toString());
System.out.println(sb==sb2);
System.out.println(sb2==sb3);
System.out.println(sb4==sb5);
System.out.println(sb3==sb4);
//采用链式编程
StringBuffer stringBuffer = new StringBuffer();
stringBuffer.append("eee").append("eeeee").append("ddddd");
String string = stringBuffer.toString();
System.out.println(string);
}
}
StringBuffer的删除功能
StringBuffer的删除功能
public StringBuffer deleteCharAt(int index)
删除指定位置的字符,并返回本身
public StringBuffer delete(int start,int end)
删除从指定位置开始指定位置结束的内容,并返回本身
public class Test {
public static void main(String[] args) {
System.out.println("==========StringBuffer的删除功能===========");
StringBuffer sb = new StringBuffer("我是一个么的感情的恰饭机器,23333333");
System.out.println("=======删除指定位置的字符,并返回本身=========");
//public StringBuffer deleteCharAt(int index)
//删除指定位置的字符,并返回本身
System.out.println(sb.deleteCharAt(0).deleteCharAt(0).deleteCharAt(0).deleteCharAt(0));
//public StringBuffer delete(int start,int end)
//删除从指定位置开始指定位置结束的内容,并返回本身
System.out.println("=删除从指定位置开始指定位置结束的内容,并返回本身=");
sb.delete(1,5);//含头不含尾,删除了从1-4的字符
System.out.println(sb);
}
}
StringBuffer的替换和反转功能
StringBuffer的替换功能
public StringBuffer replace(int start,int end,String str)
从start开始到end用str替换
StringBuffer的反转功能
public StringBuffer reverse()
字符串反转
public class Test2 {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer("我是一个么的感情的恰饭机器,23333333");
System.out.println("==========StringBuffer的替换功能==========");
//根据起始索引和终止索引,替换一段内容。返回的还是容器本身
System.out.println(sb.replace(3, 7, "5555555"));
System.out.println("==========StringBuffer的反转功能==========");
//反转容器中的数据,返回的还是容器本身
System.out.println(sb.reverse());
}
}
StringBuffer的索引功能
从前索引
int indexOf(String str)
int indexOf(String str, int fromIndex)
E:从后开始索引
int lastIndexOf(String str)
int lastIndexOf(String str, int fromIndex)
public class Test4 {
public static void main(String[] args) {
//从头查找该字符串,在容器中第一次出现的索引,如果找不到就返回-1
// int indexOf (String str)
//从指定索引处开始查找该字符串第一次出现的索引,如果找不到就返回-1
// int indexOf (String str,int fromIndex)
/*int lastIndexOf (String str)
int lastIndexOf (String str,int fromIndex)*/
StringBuffer sb = new StringBuffer("我是一个么的感情个的恰饭机器,23333333");
int index1=sb.indexOf("个");
int index2=sb.indexOf("个",index1+1);
System.out.println("数组中第一个‘个’字的索引是"+index1);
System.out.println("数组中第二个‘个’字的索引是"+index2);
}
}
StringBuffer的截取功能及注意事项
public class Test3 {
public static void main(String[] args) {
System.out.println("=======StringBuffer的截取功能========");
StringBuffer sb = new StringBuffer("我是一个么的感情的恰饭机器,23333333");
//截取容器中的一段内容,返回的是截取到的字符串
//从3索引处,截取到末尾
System.out.println(sb.substring(3));
//根据起始索引和终止索引,截取一段内容,以String类型返回。不会影响,容器中的内容
System.out.println(sb.substring(2, 8));
System.out.println(sb);
}
}
StringBuffer和String的相互转换
A:String -- StringBuffer
a:通过构造方法
b:通过append()方法
B:StringBuffer -- String
a: 使用substring方法
b:通过构造方法
c:通过toString()方法
public class Test1 {
public static void main(String[] args) {
System.out.println("======StringBuffer和String的相互转换=====");
System.out.println("========StringBuffer----->String=======");
StringBuffer sb = new StringBuffer("1234895");
sb.append("abcdefg");
System.out.println(sb);
System.out.println("==========方式1:使用toString方法========");
String str=sb.toString();
System.out.println(str);
System.out.println("===========方式2:截取,从0截取到尾========");
String str1 = sb.substring(0);
System.out.println(str1);
System.out.println("=========方式3:;用String的构造方法=======");
String s = new String(sb);
System.out.println(s);
System.out.println("========String----->StringBuffer========");
System.out.println("=====方式1:采用StringBuffer的构造方法=====");
String str2="我是一个么的感情的恰饭机器,23333333";
StringBuffer sb2 = new StringBuffer(str2);
System.out.println("==方式2:方式2:使用append() insert()方法==");
StringBuffer sb3 = new StringBuffer();
sb3.append(str);
sb3.insert(0,str);
}
}
案例演示
把数组转成字符串
A:案例演示
需求:把数组中的数据按照指定个格式拼接成一个字符串
举例:
int[] arr = {1,2,3};
输出结果:
"[1, 2, 3]"
用StringBuffer的功能实现
public class Test {
public static void main(String[] args) {
/*A:案例演示
需求:把数组中的数据按照指定个格式拼接成一个字符串
举例:
int[] arr = {1,2,3};
输出结果:
"[1, 2, 3]"
用StringBuffer的功能实现*/
int[] arr = {1, 2, 3, 4, 5, 6};
StringBuffer sb = new StringBuffer("[");
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) {
sb.append(arr[i]).append("]");
} else {
sb.append(arr[i]).append(",");
}
}
System.out.println(sb);
}
}
字符串反转
A:案例演示
需求:把字符串反转
举例:键盘录入"abc"
输出结果:"cba"
用StringBuffer的功能实现
public class Test2 {
public static void main(String[] args) {
/*A:案例演示
需求:把字符串反转
举例:键盘录入"abc"
输出结果:"cba"
用StringBuffer的功能实现 */
Scanner sc = new Scanner(System.in);
System.out.println("请输入字符串");
String s = sc.nextLine();
String sb = new StringBuffer(s).reverse().toString();
System.out.println(sb);
}
}
StringBuffer和StringBuilder的区别
会出面试题
StringBuffer和StringBuilder的区别
* 他们两个的API是一样的
* 区别是:线程安全方面的区别
* StringBuffer是线程安全的,效率低
* StringBuilder线程不安全,效率高。
* 在单线程环境下,StringBuilder的实现功能大部分比StringBuffer要快。
* 多线程环境下 StringBuilder会产生线程安全问题
StringBuilder 一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API,
但不保证同步。该类被设计用作 StringBuffer 的一个简易替换,
用在字符串缓冲区被单个线程使用的时候(这种情况很普遍)。如果可能,
建议优先采用该类,因为在大多数实现中,它比 StringBuffer 要快
public class Test {
public static void main(String[] args) {
//引用类型作为参数传递,传递的是地址值,形参的改变会影响实参(String例外)
//但是字符串比较特殊,虽说String是引用类型,但是他作为参数传递,属于值传递
String str="abc";
test(str);
System.out.println(str);//2、abc
}
private static void test(String str){
str+="I love you";
System.out.println(str);//1、abcI love you
}
}
数组的常见操作
数组排序:把一个无需序列,通过比较交换等手段,使其变成了一个有序序列
排序方法:冒泡排序、选择排序、插入排序、快速排序、归并排序、基数排序、堆排序等
冒泡排序
public class Test {
public static void main(String[] args) {
//数组排序:把一个无需序列,通过比较交换等手段,使其变成了一个有序序列
//排序方法:冒泡排序、选择排序、插入排序、快速排序、归并排序、基数排序、堆排序等
System.out.println("=============冒泡排序===============");
//数组中的元素两两比较,大的往后放,经过一轮比较后,最大的元素就出现在了最后面
int[] arr = {24, 69, 80, 57, 13};
fun(arr);
//时间复杂度N*N
for (int j = 0; j < 4; j++) {
for (int i = 1; i < arr.length; i++) {
if (arr[i - 1] > arr[i]) {
int t = arr[i - 1];
arr[i - 1] = arr[i];
arr[i] = t;
}
}
}
System.out.println(Arrays.toString(arr));
}
//把一块代码抽取为函数,ctrl+alt+m
//用循环嵌套,但是要注意空间复杂度
private static void fun(int[] arr) {
for (int i = 1; i < arr.length; i++) {
if (arr[i - 1] > arr[i]) {
int t = arr[i - 1];
arr[i - 1] = arr[i];
arr[i] = t;
}
}
System.out.println(Arrays.toString(arr));
for (int i = 1; i < arr.length - 1; i++) {
if (arr[i - 1] > arr[i]) {
int t = arr[i - 1];
arr[i - 1] = arr[i];
arr[i] = t;
}
}
System.out.println(Arrays.toString(arr));
for (int i = 1; i < arr.length - 2; i++) {
if (arr[i - 1] > arr[i]) {
int t = arr[i - 1];
arr[i - 1] = arr[i];
arr[i] = t;
}
}
System.out.println(Arrays.toString(arr));
for (int i = 1; i < arr.length - 3; i++) {
if (arr[i - 1] > arr[i]) {
int t = arr[i - 1];
arr[i - 1] = arr[i];
arr[i] = t;
}
}
System.out.println(Arrays.toString(arr));
}
}
选择排序
public class Test2 {
public static void main(String[] args) {
System.out.println("=============选择排序===============");
//从0索引处元素开始,依次跟他后面的元素挨个比较,小的往前放,经过一轮比较,最小的就出现在最前面
int[] arr={24, 69, 80, 57, 13};
for (int i = 0; i < arr.length-1; i++) {
for(int j=i+1;j<arr.length;j++)
if(arr[i]>arr[j]){
int t=arr[i];
arr[i]=arr[j];
arr[j]=t;
}
System.out.println(Arrays.toString(arr));
}
System.out.println(Arrays.toString(arr));
}
}
直接插入排序
public class Test3 {
public static void main(String[] args) {
System.out.println("=============直接插入排序===============");
//每次拿后面的一个元素,与前面所有的元素比较,无序则交换位置,使之仍保持有序
//[2,3,9,9,6]此为无序序列,由小到大排列是为有序
//[2]若序列中只有一个元素,就是有序序列
int[] arr = {2, 7, 1, 8, 3, 6};
for (int i = 1; i < arr.length; i++) {
//此处为反向遍历,由于交换后需要与前面的所有值进行比较
for (int j = i; j > 0; j--) {
//如果当前元素小于前一个元素,交换位置
if (arr[j] < arr[j - 1]) {
int t = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = t;
}
}
}
System.out.println(Arrays.toString(arr));
}
}
快速排序
public class Test4 {
public static void main(String[] args) {
System.out.println("=============快速排序===============");
/*1、从数组中取出一个数,作为基准数
* 2、分区:将比这个数大或等于的数都方到他的右边,比他小的数都放到他的左边
* 3、分区重复以上操作*/
/*实现思路:挖坑填数
从另一端寻找交换
* 1、将基准数挖出形成第一个坑
* 2、由后向前找比他小的数,将这个数填入前一个坑中
* 3、再从前向后找,找到比他大的数,将这个数填入前一个坑中
* 4、重复执行以上2、3步。
* …………………………*/
int[] arr={2,7,1,8,3,6,54,46,8,45,3,68,76,84};
ArrUtils.quickSort(0,arr.length-1,arr);
System.out.println(Arrays.toString(arr));
}
}
public class ArrUtils {
/**
* @param arr 待排序数组
* @param start 起始索引
* @param end 终止索引
*/
//快速排序方法
public static void quickSort(int start, int end, int arr[]) {
if(start<end){
//递归,不断分区,不断获取基数的索引,得到分区的界限(此处的分区数>=2)
int index=getIndex(start,end,arr);
//分区界限索引得到,对分区进行递归
//对界限左边递归
quickSort(start,index-1,arr);
//对界限右边递归
quickSort(index+1,end,arr);
}
}
private static int getIndex(int start, int end, int[] arr) {
//寻找基准数的索引位置
int i = start;
int j = end;
//1、找一个数作为基准数,并将基准数挖出来
int x = arr[i];
//4、重复2,3两步
while (i < j) {
//2、由后向前找比基准数小的数,将这个数填入前一个坑中
/************************************************************************
* 这里不直接将if语句放在while中寻找小值是为了考虑代码的时间复杂度
* 在考虑其他算法时,当正向考虑需要用到嵌套时
* 不妨用while考虑为false时去执行下一段代码
否则为真就不停执行while里面的代码
* 尽量少用到嵌套 *************************************************************************/
while (i<j&&arr[j] >= x) {
j--;
}//跳出这个循环,就是找到了比基数大的数
//找到之后挖坑填数
if (i < j) {
arr[i] = arr[j];//此时索引i处的值已经小于基数
//下一步是找比基数大的数可以不管i索引处的值,从i的下一个开始考虑
i++;
}
//接着从前向后大于等于基数的数
while(i<j&&arr[i]<x){
i++;
}//出了这个循环就是找到了大于等于基数的索引值i
//上一步找最小值的时候就把索引j处的值挖出给了基准值所在的位置
//现在将索引值填入j索引处
if(i<j){
arr[j]=arr[i];
j--;
}
}
//将基准值填入最后一个坑中
arr[i]=x;
return i;//i==j,返回基数所在位置
}
}
二分查找
每次都找中间的数比大小
前提数组元素必须有序
public class Test6 {
public static void main(String[] args) {
System.out.println("==查找输入元素在数组中第一次出现的索引===");
Scanner sc = new Scanner(System.in);
System.out.println("请输入要索引的整数");
int s = sc.nextInt();
System.out.println("===============基本查找===============");
int[] arr = {2, 7, 1, 8, 3, 6, 54, 46, 8, 45, 3, 68, 76, 84};
System.out.println(arr[getIndex(arr, s)] + "的索引值为" + getIndex(arr, s));
System.out.println("==============二分查找================");
//元素必须有序,先排序,再查找
GetSort.quickSort(0, arr.length - 1, arr);
System.out.println(Arrays.toString(arr));
//二分查找的思想:每一次都查中间的那个元素,比较大小就能减少一半的元素
System.out.println(getIndex2(arr, s));
}
private static int getIndex2(int[] arr, int ele) {
//定义最小索引
int minIndex = 0;
//定义最大索引
int maxIndex = arr.length - 1;
//计算中间索引
int mediaIndex = (minIndex + maxIndex) / 2;
//比大小
while (minIndex <= maxIndex) {
//如果我们要找的索引正好等于中间索引所对应的元素,就直接返回中建索引
if (arr[mediaIndex] == ele) {
return mediaIndex;
} else if (ele < arr[mediaIndex]) {
maxIndex=mediaIndex-1;
} else if (ele>arr[mediaIndex]) {
minIndex=mediaIndex+1;
}
mediaIndex=(minIndex + maxIndex)/2;
}
return -1;
}
private static int getIndex(int[] arr, int inPut) {
int index = 0;
for (int i = 0; i < arr.length; i++) {
if (inPut == arr[i]) {
index = i;
break;
} else {
index = -1;
}
}
return index;
}
}
//快速排序
class GetSort {
public static void quickSort(int start, int end, int[] arr) {
if (start < end) {
int index = getIndex(start, end, arr);
quickSort(start, index - 1, arr);
quickSort(index + 1, end, arr);
}
}
private static int getIndex(int start, int end, int[] arr) {
int x = arr[start];
while (start < end) {
while (start < end && arr[end] >= x) {
end--;
}
if (start < end) {
arr[start] = arr[end];
start++;
}
while (start < end && arr[start] < x) {
start++;
}
if (start < end) {
arr[end] = arr[start];
end++;
}
}
arr[start] = x;
return start;
}
}
Arrays
A:Arrays类概述
针对数组进行操作的工具类。
提供了排序,查找等功能。
B:成员方法
public static String toString(int[] a)
public static void sort(int[] a)
public static int binarySearch(int[] a,int key)
static boolean equals(int[] a, int[] a2)
比较两个数组中的元素,是否一样
static int[] copyOf(int[] original, int newLength)
复制旧数组中的元素到一个新的数组中,新的数组长度是newLength 从0开始复制旧数组
static int[] copyOfRange(int[] original, int from, int to)
复制旧数组中的指定范围间的几个元素到新数组中
public class Test2 {
public static void main(String[] args) {
int[] arr={2,7,1,8,3,6,54,46,8,45,3,68,76,84};
int[] arr2={2,7,1,8,3,6,54,46,8,45,3,68,76,84};
System.out.println("============打印数组============");
//public static String toString(int[] a)
System.out.println(Arrays.toString(arr));
System.out.println("============排序数组============");
//public static void sort(int[] a)
Arrays.sort(arr);
Arrays.sort(arr2);
System.out.println(Arrays.toString(arr));
System.out.println(Arrays.toString(arr2));
System.out.println("============二分查找============");
//数组必须有序
//public static int binarySearch(int[] a,int key)
int index = Arrays.binarySearch(arr,8);
System.out.println(index);
System.out.println("==比较两个数组中的元素,是否一样==");
//static boolean equals(int[] a, int[] a2)
System.out.println(Arrays.equals(arr, arr2));
System.out.println("============复制数组============");
//static int[] copyOf(int[] original, int newLength)
// 复制旧数组中的元素到一个新的数组中,新的数组长度是newLength 从0开始复制旧数组
System.out.println(Arrays.toString(Arrays.copyOf(arr, 8)));
//static int[] copyOfRange(int[] original, int from, int to)
//复制旧数组中的指定范围间的几个元素到新数组中
System.out.println(Arrays.toString(Arrays.copyOfRange(arr, 2, 8)));
}
}
基本数据类型包装类
概述
为了使基本数据类型之间,基本数据类型与引用类型之间,基本数据类型与二进制,八进制、十六进制之间的转换更加的简便,Java将基本数据类型进行了包装
A: 需求:
a:将100转换成二进制 , 八进制 , 十六进制
b:判断一个数是否在int的范围内
B:为什么会有基本类型包装类
为了对基本数据类型进行更多的操作,更方便的操作,java就针对每一种基本数据类型提供了对应的类类型.
C:常用操作: 常用的操作之一:用于基本数据类型与字符串之间的转换。
D:基本类型和包装类的对应
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
public class Test1 {
public static void main(String[] args) {
/*****************************************
* A: 需求:
* a:将100转换成二进制 , 八进制 , 十六进制
* b:判断一个数是否在int的范围内
* 用于基本数据类型与字符串之间的转换。
*
* 基本类型和包装类的对应
* byte Byte
* short Short
* int Integer
* long Long
* float Float
* double Double
* char Character
* boolean Boolean
*
* 他们都是Number类的子类
* 所有的包装类的构造方法作用都差不多
* 只有两个构造方法,都会返回一个输入参数类型的对象
* 所有类型的包装类都会有
* valueOf方法--->返回输入参数的对应基本类型数据的包装类实例
* toString方法--->无参:返回包装类的String对象
* 有参:返回输入基本数据类型参数的String对象
* parseXXX方法--->将字符串参数解析为包装类对应的基本数据类型的有符号表示
* equals方法--->重写了Object类的equals,比较内容
* getXXX方法--->确定具有指定名称的系统属性的 long 值
* XXXValue方法--->以XXX形式返回包装类的值
* *******************************************/
System.out.println("============Integer============");
/********************************************
* 构造方法
* public Integer(int value)
*
* public Integer(String s)
* 要一个字面上是数字的字符串,如果不是就会报错
* *******************************************/
System.out.println("=================构造方法==================");
//public Integer(int value)--->创建一个Integer对象
//并给Integer类中的成员变量value赋值num
int num=100;
Integer integer = new Integer(num);
//public Integer(String s)
//要一个字面上是数字的字符串,如果不是就会报错
String str="100";
Integer integer1 = new Integer(str);
int i = integer1.intValue();
System.out.println(i);
}
}
Integer为例说明构造方法和常用成员方法的作用
String和int类型的相互转换
public class Test2 {
public static void main(String[] args) {
System.out.println("==============int --> String==============");
int num=100;
System.out.println("===============方式1:拼接空串===============");
String str=Integer.toString(num);
System.out.println(str);
System.out.println("======方式2:String类中的静态方法valueOf======");
//这个常用
String s = String.valueOf(num);
System.out.println(s);
System.out.println("======方式3:int --> Integer --> String======");
Integer integer = new Integer(num);
String s1 = integer.toString();
System.out.println(s1);
System.out.println("===============String --> int===============");
String s2="200";
System.out.println("==方式1:String --> Integer --> intValue();==");
Integer integer1 = new Integer(s2);
int i = integer1.intValue();
System.out.println(i);
System.out.println("=方式2:public static int parseInt(String s)=");
//NumberFormatException 你传入给parseInt()方法的参数,字面上不是一个有效的数字,会报异常
//parseInt方法会校验输入的字符串的长度
int i1 = Integer.parseInt(s2);
System.out.println(i1);
}
}
Integer----->其他类型的转换
public class Test3 {
public static void main(String[] args) {
//Integer 类在对象中包装了一个基本类型 int 的值。Integer 类型的对象包含一个 int 类型的字段。
int num=100;
String s = Integer.toBinaryString(num);
//把一个整数值,转换成16进制
String string = Integer.toHexString(num);
String string1 = Integer.toOctalString(num);
System.out.println(s);
System.out.println(string);
System.out.println(string1);
System.out.println("==================================");
}
}
JDK5的新特性自动装箱和拆箱
public class Test1 {
public static void main(String[] args) {
//自动拆装箱:JDK1.5之后,引入的一个新特性
//自动拆箱:将一个包装类型自动转换成他所对应的基本类型
//自动装箱:将一个基本数据类型自动转换成他所对应的包装类型
int num=100;
//Integer integer = new Integer(num);
//自动装箱
Integer integer=num;
Integer integer1=200;
System.out.println("字符串类型"+integer.toString());
//自动拆箱
Integer a = new Integer("30000");
//将引用类型a自动拆箱成基本类型30000
int r=a+2;
System.out.println(r);
}
public class Test2 {
public static void main(String[] args) {
/********************************
* 由Integer构造知,创建Integer对象,输入一个int就是int本身
* 输入String类型,表示String参数所指定的int值
* 可以调用所有的Integer方法去对int数据进行转化
* *****************************/
//一个原始类型会自动转换为对象;对象会自动转换为原始类型
//自动装箱
Integer a = 20, b = 20, c = 150, d = 150;
//当你输入的整型数据在-128~127之间时,会正常缓存
//当你输入的整型数据在-128~127之外时,会new新的对象,所以c,d不在一个对象内
System.out.println(a == b);//true
System.out.println(c == d);//false
System.out.println(a.equals(b));
System.out.println(c.equals(d));
//intValue 手动拆箱
int i = a.intValue();
int i1 = b.intValue();
//手动装箱
int num = 300;
String str = "40000";
Integer integer = new Integer(num);
Integer integer1 = Integer.valueOf(str);
//手动拆箱
int t=integer1.intValue();
System.out.println(t);
}
}
public class Test3 {
public static void main(String[] args) {
Integer a=20;
Integer b=20;
//intValue() 手动拆箱
int i = a.intValue();
int i1 = b.intValue();
System.out.println(i+i1);
//手动装箱
//手动装箱有两种方法
//1、用构造方法创建对象
//2、用成员方法valueOf()创建对象
//valueOf有方法重载,可以输入int、String等,都会返回一个封装类的对象
int num=300;
//Integer integer = new Integer(num);//用构造方法装箱
Integer integer = Integer.valueOf(num);//用成员方法装箱
System.out.println(integer.toString());
Integer integer1 = Integer.valueOf("300000");
int t=integer1.intValue();
System.out.println(t);
}
}
public class Test4 {
public static void main(String[] args) {
int[] arr={20,30,20};
//Integer a=arr[0]; 自动装箱
//自动装箱
//Integer可以直接通过类名调用里面的valueOf来创建对象
Integer[] arr2={20,30,20,new Integer(200),Integer.valueOf(20)};
String string = arr2[0].toString();
System.out.println(string);//字符串
int t=Integer.parseInt(string);
System.out.println(t);//t为int型数据
//自动装箱
Integer[] arr3 = {20, 30, 20,20,30};
int b=arr3[0]; //自动拆箱
Integer c=arr3[3];
int sum=0;
for (int i = 0; i < arr3.length; i++) {
sum+=arr3[i];
}
}
}
拆装箱具有的特性以及面试中会考到,注意分析本段最后的注释代码
public class Test2 {
public static void main(String[] args) {
//自动装箱 在内部会调用 Integer.valueOf(128) 装箱
Integer i5 = 128;
Integer i6 = 128;
//比较两个对象的地址值
System.out.println(i5 == i6); //false
System.out.println("-----------");
//自动装箱 在内部会调用 Integer.valueOf(128) 装箱
//在Integer类里面有一个静态的内部类IntegerCache他有一个静态代码块
//当Integer类一加载,静态的的内部类IntegerCache也加载,IntegerCache他里面的静态代码块也得加载。
//静态代码块里面会有一个Integer cache[];这个数组
//这个数组里面,放的就是一些提前创建好的Interge对象。
// 当我们采用 Integer i7 = 127;这种方式定义一个Integer对象时,如果值在 -128到127 之间
//他会从cache[]数组中返回一个对象给你
Integer i7 = 127;
Integer i8 = 127;
//比较两个对象的地址值
System.out.println(i7 == i8); //true表明这是同一个对象
//当你输入的整型数据在-128~127之外时,会new新的对象,所以c,d不在一个对象内
Integer c=150;
Integer d=150;
System.out.println(c == d);//false
System.out.println(c.equals(d));
//装箱 调用valueOf()方法根据输入的参数会返回一个参数对应的Integer对象
/* public static Integer valueOf ( int i){
if (i >= Integer.IntegerCache.low && i <= Integer.IntegerCache.high)
return Integer.IntegerCache.cache[i + (-Integer.IntegerCache.low)];
return new Integer(i);
}*/
}
}
IntegerCache他有一个静态代码块
//当Integer类一加载,静态的的内部类IntegerCache也加载,IntegerCache他里面的静态代码块也得加载。
//静态代码块里面会有一个Integer cache[];这个数组
//这个数组里面,放的就是一些提前创建好的Interge对象。
// 当我们采用 Integer i7 = 127;这种方式定义一个Integer对象时,如果值在 -128到127 之间
//他会从cache[]数组中返回一个对象给你
Integer i7 = 127;
Integer i8 = 127;
//比较两个对象的地址值
System.out.println(i7 == i8); //true表明这是同一个对象
//当你输入的整型数据在-128~127之外时,会new新的对象,所以c,d不在一个对象内
Integer c=150;
Integer d=150;
System.out.println(c == d);//false
System.out.println(c.equals(d));
//装箱 调用valueOf()方法根据输入的参数会返回一个参数对应的Integer对象
/* public static Integer valueOf ( int i){
if (i >= Integer.IntegerCache.low && i <= Integer.IntegerCache.high)
return Integer.IntegerCache.cache[i + (-Integer.IntegerCache.low)];
return new Integer(i);
}*/
}
}