java中ArrayList和 int[]的区别

一、arraylist

https://www.runoob.com/java/java-arraylist.html
ArrayList 类是一个可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制，我们可以添加或删除元素。
ArrayList 继承了 AbstractList ，并实现了 List 接口。

1.初始化

ArrayList 类位于 java.util 包中，使用前需要引入它，语法格式如下：

import java.util.ArrayList; // 引入 ArrayList 类
ArrayList<E> objectName =new ArrayList<>();　 // 初始化
/*
E: 泛型数据类型，用于设置 objectName 的数据类型，只能为引用数据类型。（这里的引用数据类型指的是基本数据类型的包装类，因为ArrayList 中的元素实际上是对象）
objectName: 对象名。
*/

基本类型对应的包装类表如下：

2.使用方法

1. 添加元素：add() //将元素插入到指定位置的 arraylist 中
2. 访问元素：get() eg:sites.get(1)//访问第2个元素 数组的索引值从 0 开始
3. 修改元素：set() ,eg:set(2, “Wiki”); // 第一个参数为索引位置，第二个为要修改的值
4. 删除元素：remove(), remove(3); // 删除第四个元素
5. 计算大小：size()
6. 迭代数组列表中的元素

//直接用for
for (int i = 0; i < sites.size(); i++) {
            System.out.println(sites.get(i));
        }
 //用for each
 for (String i : sites) {
            System.out.println(i);
        }

7. 数组列表排序： sort() 方法可以对字符或数字列表进行排序 eg:Collections.sort(sites);
8. 判断某元素是否在数组列表中：contains()
   

二、int[] array

https://blog.csdn.net/a4459/article/details/90516426

1.初始化

Java是静态语言，因此Java的数组也是静态的。就是说数组在被初始化后数组的长度是不可改变的。而Java的数组初始化就是给数组对象分配内存空间并且给每个数组元素给予初始值。

​1.1 数组的初始化方式可分为静态初始化和动态初始化

1. 静态初始化：程序员决定数组元素的初始值，系统决定长度

String[] names = new String[]{"张三","李四","王五"}；
String[] books = {"射雕英雄传","天龙八部","笑傲江湖"}；

2. 动态初始化:程序员只决定数组元素的长度，系统分配元素初始值（通常为null，0等）

String[] strAll = new String[5];

数组对象的长度初始化后长度就不可改变了，他们在堆内存中已经开辟了对应大小的内存空间。数组变量是一个引用类型的变量，数组变量在栈内存中指向存放在堆内存中的数组对象。内存分配如下图所示：

1.2 基本类型数组和引用类型的数组初始化的不同

1. 基本类型数组初始化
对于基本类型的数组，他们的初始化就是在堆内存中开辟一个固定长度和大小的空间用于存储基本类型数据。
​ 比如int（初始值为0)，float（初始值为0.0），char（初始值为‘\u0000’），boolean（初始值为false）等。
对应数组类型只能存储对应的数据，并且可以替换，但唯一不变的是数组的长度大小不会变。

public static void main(String[] args){
    //动态初始化int数组nums，长度为5
    int[] nums = [5];
    //给nums数组设置元素
    for(i=0;i<5;i++){
        nums[i]=i;
    }
}

上述这段代码，在内存中的变化如下图：

从这个图可以看出，基本类型的数组元素都是存在数组开辟的内存空间中，并且长度不变，元素可以替换。相当于一个瓶子里可以装可乐也可以装雪碧，只要你是液体的就行，瓶子只有那么大只能装那么多。

2. 引用类型数组初始化
​ 引用类型的数组，它初始化完成后数组长度也是固定的，和基本类型数组不同的地方就是数组对象元素。基本类型数组元素是存放对应基本类型的元素具体值，而引用类型数组对象元素存放的是引用，这个引用指向堆内存中另一块内存空间。

public class Cat{
    //体重
    public double weight;
    //年龄
    public int age;
}

public class Test{
    public static void main(String[] args){
        //定义一个数组变量cats，类型是Cat{}
        Cat[] cats;
        //执行动态初始化数组，长度为2
		cats = new Cat[2];
        //创建两个Cat类型的对象
      	Cat cat1 = new Cat{}
        Cat cat2 = new Cat{}
        //赋值给对象的属性
        cat1.weight=45.2;
        cat1.age=2;
        cat2.weight=35.5;
        cat2.age=1;
        //把对象存入数组元素
        cats[0] = cat1;
        cat2[1] = cat2;
    }
   
}

cat1和cat2作为数组的元素存入数组，内存解析如下图：

代码执行顺序如上图序号所示，所以在堆内存中，引用类型的数组元素就是一个对象的引用。它们在赋值过程中相当于是把自己的指向地址给了数组元素，可以说是cat1=cats[0]。还可以把引用看做是一个堆内存地址指针，它指向的堆内存的对象。

2.array和arraylist的区别

https://cloud.tencent.com/developer/article/1530730

1. Array本质上是静态的，即创建后就无法更改其大小，但是ArrayList是动态数组，如果ArrayList中的元素数大于其阈值，则可以调整自身大小。
   ArrayList的size()增长方式：初始化长度为10，一段超过1.5倍自动扩容。arr.minCapacity=arr.minCapacity+arr.minCapacity/2;
2. 长度计算：array.length 和arraylist,size();

3.array和arraylist的相互转化

https://www.jianshu.com/p/7eee157f74fc

3.1 array转化为arraylist

3.2 arraylist转化为array

三、int和integer的区别

https://blog.csdn.net/chenliguan/article/details/53888018

1.java两种数据类型

1.1 java两种数据类型分类

https://www.runoob.com/java/java-basic-datatypes.html
1.基本数据类型(8种)：

关键字	byte	short	int	long	float	double	char	boolean
类型名称	字节型	短整型	整型	长整型	单精度浮点型	双精度浮点型	字符型	布尔型
封装类	java.lang.Byte	java.lang.Short	java.lang.Integer	java.lang.Long	java.lang.Float	java.lang.Double	java.lang.Character	Boolean
字节数	1	2	4	8	4	8	2	1
二进制位数	8	16	32	64	32	64	16	8

2.引用数据类型，分为数组、类、接口。

1.2Java为每个基本数据类型提供了封装类

为了编程的方便还是引入了基本数据类型，但是为了能够将这些基本数据类型当成对象操作，Java为每 一个基本数据类型都引入了对应的包装类型（wrapper class），int的包装类就是Integer，从Java 5开始引入了自动装箱/拆箱机制，使得二者可以相互转换。

基本数据类型: boolean，char，byte，short，int，long，float，double
封装类类型：Boolean，Character，Byte，Short，Integer，Long，Float，Double

2.integer和int的对比

1.integer是int的包装类，int是基本数据类型；
2.integer变量必须实例化之后才能使用，int变量不需要
3.integer是对象的引用，指向此new的integer对象，int是直接存储数值；
4.integer默认是null，int默认是0；

3.integer和int的深入对比

3.1 两new生成的integer变量比较为false

由于integer变量实际上是对integer对象的引用，所以两个通过new生成的integer变量永远是不相等的（因为new生成的两个对象，其内存地址是不同的）

Integer i = new Integer(100);
Integer j = new Integer(100);
System.out.print(i == j); //false

3.2 int和integer变量比较为true

integer变量和int变量比较时，只要两个变量的值是相等的，则结果为true。（因为包装类integer和基本数据类型int比较时，java会自动拆包装为int，然后进行比较，实际就是两个int变量的比较）

Integer i = new Integer(100);
int j = 100；
System.out.print(i == j); //true

3.3 非new的integer和new的integer比较为false

非new生成的Integer变量和new Integer()生成的变量比较时，结果为false。因为非new生成的integer变量指向的是静态变量池中cache数组中存储的指向了堆中的integer对象，而new integer()生成的变量指向堆中新建的对象，两者在内存中的对象引用地址不同

Integer i = new Integer(100);
Integer j = 100;
System.out.print(i == j); //false

3.4 两个非new integer变量的比较

对于两个非new生成的Integer对象，进行比较时，如果两个变量的值在区间-128到127之间，则比较结果为true，如果两个变量的值不在此区间，则比较结果为false

Integer i = 100;
Integer j = 100;
System.out.print(i == j); //true

Integer i = 128;
Integer j = 128;
System.out.print(i == j); //false

原因是，java在编译Integer i = 100 ;时，会翻译成为Integer i = Integer.valueOf(100)。而java API中对Integer类型的valueOf的定义如下，对于-128到127之间的数，会进行缓存，Integer i = 127时，会将127这个Integer对象进行缓存，下次再写Integer j = 127时，就会直接从缓存中取，就不会new了。

public static Integer valueOf(int i){
    assert IntegerCache.high >= 127;
    if (i >= IntegerCache.low && i <= IntegerCache.high){
        return IntegerCache.cache[i + (-IntegerCache.low)];
    }
    return new Integer(i);
}

4.自动装箱和拆箱

4.1 自动装箱：将基本数据类型重新转化为对象

    public class Test {  
        public static void main(String[] args) {  
            // 声明一个Integer对象，用到了自动的装箱：解析为:Integer num = Integer.valueOf(9);
	        Integer num = 9;
        }  
    }  

9是属于基本数据类型的，原则上它是不能直接赋值给一个对象Integer的。但jdk1.5后你就可以进行这样的声明，自动将基本数据类型转化为对应的封装类型，成为一个对象以后就可以调用对象所声明的所有的方法。

4.2 自动拆箱：将对象重新转化为基本数据类型

 public class Test {  
        public static void main(String[] args) {  
            / /声明一个Integer对象
	        Integer num = 9;
            
            // 进行计算时隐含的有自动拆箱
		    System.out.print(num--);
        }  
    }  

因为对象时不能直接进行运算的，而是要转化为基本数据类型后才能进行加减乘除。对比：

// 装箱
Integer num = 10;
// 拆箱
int num1 = num;