常用类之集合：ArrayList类

本是古典何须时尚 2022-11-05 15:54 230阅读 0赞

**ArrayList类**

数组有一个缺点：一旦创建，程序运行期间长度不可以发生改变。  
但是ArrayList类出现解决了这一问题！

数组的长度不可以发生改变。  
但是ArrayList集合的长度是可以随意变化的。

对于ArrayList来说，有一个尖括号代表泛型。  
泛型：也就是装在集合当中的所有元素，全都是统一的什么类型。  
注意：泛型只能是引用类型，不能是基本类型。

**注意事项：**  
对于ArrayList集合来说，直接打印得到的不是地址值，而是内容。  
如果内容是空，得到的是空的中括号：\[\]

public class Demo02ArrayList {
    
        public static void main(String[] args) {
            // 创建了一个ArrayList集合，集合的名称是list，里面装的全都是String字符串类型的数据
            // 备注：从JDK 1.7+开始，右侧的尖括号内部可以不写内容，但是<>本身还是要写的。
            ArrayList<String> list = new ArrayList<>();
            System.out.println(list); // []
    
            // 向集合当中添加一些数据，需要用到add方法。
            list.add("赵丽颖");
            System.out.println(list); // [赵丽颖]
    
            list.add("迪丽热巴");
            list.add("古力娜扎");
            list.add("玛尔扎哈");
            System.out.println(list); // [赵丽颖, 迪丽热巴, 古力娜扎, 玛尔扎哈]
    
    //        list.add(100); // 错误写法！因为创建的时候尖括号泛型已经说了是字符串，添加进去的元素就必须都是字符串才行
        }
    
    }

**ArrayList当中的常用方法：**

1.  public boolean add(E e)：向集合当中添加元素，参数的类型和泛型一致。返回值代表添加是否成功。  
    备注：对于ArrayList集合来说，add添加动作一定是成功的，所以返回值可用可不用。  
    但是对于其他集合（今后学习）来说，add添加动作不一定成功。
2.  public E get(int index)：从集合当中获取元素，参数是索引编号，返回值就是对应位置的元素。
3.  public E remove(int index)：从集合当中删除元素，参数是索引编号，返回值就是被删除掉的元素。
4.  public int size()：获取集合的尺寸长度，返回值是集合中包含的元素个数。

public class Demo03ArrayListMethod {
    
        public static void main(String[] args) {
            ArrayList<String> list = new ArrayList<>();
            System.out.println(list); // []
    
            // 向集合中添加元素：add
            boolean success = list.add("柳岩");
            System.out.println(list); // [柳岩]
            System.out.println("添加的动作是否成功：" + success); // true
    
            list.add("高圆圆");
            list.add("赵又廷");
            list.add("李小璐");
            list.add("贾乃亮");
            System.out.println(list); // [柳岩, 高圆圆, 赵又廷, 李小璐, 贾乃亮]
    
            // 从集合中获取元素：get。索引值从0开始
            String name = list.get(2);//获取位置为2的元素
            System.out.println("第2号索引位置：" + name); // 赵又廷
    
            // 从集合中删除元素：remove。索引值从0开始。
            String whoRemoved = list.remove(3);//删除位置为3的元素
            System.out.println("被删除的人是：" + whoRemoved); // 李小璐
            System.out.println(list); // [柳岩, 高圆圆, 赵又廷, 贾乃亮]
    
            // 获取集合的长度尺寸，也就是其中元素的个数
            int size = list.size();
            System.out.println("集合的长度是：" + size);
        }
    
    }

**如果希望向集合ArrayList当中存储基本类型数据，必须使用基本类型对应的“包装类”。**

基本类型 --------- 包装类（引用类型，包装类都位于java.lang包下）

<table> 
 <thead> 
  <tr> 
   <th>byte</th> 
   <th>Byte</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>short</td> 
   <td>Short</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>Integer 【特殊】</td> 
  </tr> 
  <tr> 
   <td>long</td> 
   <td>Long</td> 
  </tr> 
  <tr> 
   <td>float</td> 
   <td>Float</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>Double</td> 
  </tr> 
  <tr> 
   <td>char</td> 
   <td>Character 【特殊】</td> 
  </tr> 
  <tr> 
   <td>boolean</td> 
   <td>Boolean</td> 
  </tr> 
 </tbody> 
</table>

从JDK 1.5+开始，支持自动装箱、自动拆箱。

> 自动装箱：基本类型 --> 包装类型  
> 自动拆箱：包装类型 --> 基本类型

public class Demo05ArrayListBasic {
    
        public static void main(String[] args) {
            ArrayList<String> listA = new ArrayList<>();
            // 错误写法！泛型只能是引用类型，不能是基本类型
    //        ArrayList<int> listB = new ArrayList<>();
    
            ArrayList<Integer> listC = new ArrayList<>();
            listC.add(100);
            listC.add(200);
            System.out.println(listC); // [100, 200]
    
            int num = listC.get(1);
            System.out.println("第1号元素是：" + num);
        }
    
    }

**补充：更加细致化ArrayList**

变量—容器  
存储一个元素

数组—容器  
一组具有某种特性的数据存放在一起  
存储一组元素(数据类型一致) 长度固定

集合—容器 与数组类似 集合的长度存储之后还能改变  
集合是用来存储一组元素  
可以理解为集合是我们封装的Box 只不过比我们写的更加的优秀 更多的方法

集合java.util  
Collection Map  
存储的都是value 存储的是以key-value形式存在

> List：有序可重复 Set：无序无重复 key无需无重复 value无需可重复  
> 序 : 顺序 添加进去的元素 取得元素的顺序一致  
> 注意指的不是集合自己的顺序 重复：两个对象元素一致

ArrayList ----Vector区别—>StringBuilder StringBuffer

**List集合**

*  1.ArrayList
 *  2.Vector
 *  3.LinkedList

ArrayList特点适合遍历轮询 不适合插入删除  
LinkedList特点适合于插入或删除 不适合遍历轮询

**1.ArrayList----->底层就是一个数组**  
所属的包 java.util  
如何创建对象  
无参数构造方法 带默认空间的构造方法 带collection参数的构造方法  
常用的方法—小容器

存 add 		
    			取 get 		
    			删 remove 		
    			改 set 		
    			个数  size
    
    			add(E e)   add(int index,E e)
    			addAll(Collection c);   add(int index,Collection c)
    			clear();将集合内的全部元素清除
    			boolean = contains(Object);找寻某一个给定的元素是否在集合中拥有
    			ensureCapacity(int minCapacity);
    			E = get(int index);
    			int = indexOf(Object obj);  lastIndexOf();
    			boolean = isEmpty();
    			Iterator = list.iterator();//迭代器
    			remove(int index)删除那个位置的元素    remove(Object obj)给一个对象然后去集合找，有就删除
    			如果remove(1);不知道是：删除那个位置的元素 还是 给一个对象然后去集合找，有就删除    1基本类型删除是remove(int index)默认的
    			如果remove(1)就想删除1这个对象   用list.remove(new Integer(1))
    			addAll()并集
    			removeAll()差集
    			retainAll();交集
    			E = set(int index,E value) 用value替换index索引位置的元素
    			int size();
    			List = subList(int begin,int end);截取从begin到end索引的元素
    			toArray();	集合变成数组
    			toArray(T[] a);
    			trimToSize();// 变成有效元素个数那么长

**关于泛型的问题：**  
由于arrayList底层是一个Object\[\] 什么类型都可以存进去  
取出来的时候多态的效果 需要自己造型 显得用起来非常的麻烦  
JDK1.5之后—>泛型  
用来规定数据类型的，定义的时候用一个符号代替某种类型  
在使用的时候用具体的数据类型 将定义的那个符号替换掉  
泛型可以用在哪里?

> 1.泛型类 类定义的时候描述某种数据类型 集合的使用就是这样  
> 2.泛型接口 与泛型类的使用基本一致 子类实现接口时必须添加泛型  
> 3.泛型方法 方法调用时传参数 方法的泛型与类无关 带有泛型的方法可以不放在带有泛型的类中  
> 4.高级泛型 规范边界 extends super

public class TestList {
        
        public static void main(String[] args) {
        
            //泛型类  现在会用这个就好了
            //ArrayList  有序可重复
            ArrayList<String> list=new ArrayList<String>();//new ArrayList<String>();1.5后可以不写<String>的String
            //定义的String类型，只能放String
            list.add("a");
            //list.add(10);//报错，只能放String类型
            list.add("b");
            list.add("c");
            list.add("d");
            list.add("e");
            list.add("a");
            /*System.out.println(list.size());//有效元素个数  //6
            //System.out.println(list.get(2));//c
            //System.out.println(list.get(6));//IndexOutOfBoundsException  集合越界
            for (int i=0;i<list.size();i++){
                String valut=list.get(i);
                System.out.println(valut);
            }*/
    
            //System.out.println(list);//正常是：list是一个对象输出 包名.类名@ hashCode
            //[a, b, c, d, e, a]  因为list底层重写了toString方法
    
            //集合的元素全部删除
            int size=list.size();//6  固定size个数,可全部删除
            for (int i=0;i<size;i++){
        //删除不干净，要固定size个数
                //list.remove(i);
                list.remove(0);
            }
            //i=0   size=6 abcdea
            //      bcdea
            //i=1   size=5 bcdea
            //      bdea
            //System.out.println(list);//bda
            //System.out.println(list);//dea
            System.out.println(list);//[]
    
    
            //泛型不能使用基本类型---如果一定要使用基本类型   需要使用其对应的包装类
            ArrayList<Integer> list1=new ArrayList<Integer>();
            list1.add(10);
            list1.add(20);
            list1.add(30);
            list1.add(40);
            list1.add(50);
            list1.add(60);
            ArrayList<Integer> list2=new ArrayList<Integer>();
            list2.add(100);
            list2.add(200);
            list2.add(300);
            //list2集合中的所有元素添加到list1中
            //list1.addAll(list2);
            list1.addAll(2,list2);//在20后面插入list2
            //list1.addAll(Cokllection<? extends E> list2)//list2类型跟list1类型至少一致  2类型小于1的类型   或者list2里的类型是list1里的子类  ？继承E
            //将list2集合中的全部元素存入list1集合中
            //list1集合存在泛型  Integer
            //list2集合存在泛型  String
            //System.out.println(list1);//[10, 20, 30, 40, 50, 60, 100, 200, 300]
            System.out.println(list1);//[10, 20, 100, 200, 300, 30, 40, 50, 60]
    //        list1.clear();//将集合内的全部元素清除
    //        System.out.println(list1);//[]
            boolean b=list1.contains(100);//给定一个元素是否在集合中存在  boolean类型
            System.out.println(b);//true
    
            int index=list1.indexOf(100);//找寻100第一次出现的位置
            System.out.println(index);//2
    
            int valut=list1.set(2,500);//将500替换位置2的元素位置
            System.out.println(list1);
            System.out.println(valut);//100  看看旧元素是什么
    
            List<Integer> newList=list1.subList(2,4);//截取索引2到4的元素  但娶不到4
            System.out.println(newList);//[500,200]
    
            Object[] array=list1.toArray();//集合变成数组
            for (Object o:array){
        
                Integer result=(Integer)o;
                System.out.println(result);
            }
    
            //事先准备好一个空的数组--->接受返回值
            Integer[] x=new Integer[list1.size()];
            list1.toArray(x);//参数
            System.out.println(x.length);//9
        }
    }