ArrayList集合概述和基本使用

  1. package com.Demo03;
  3. import java.util.ArrayList;
  5. /*
  6. 数组的长度不能改变
  7. 但是ArrayList集合的长度是可以随意变化的
  9. 对于ArrayList来说有一个尖括号<E>代表泛型
  10. 泛型：也就是装在集合当中的所有元素，全部都是统一的什么类型
  11. 【注意】：泛型只能是引用类型，不能是基本类型
  13. 【注意事项】
  14. 对于ArrayList来说，ArrayList直接打印得到的不是地址值，而是内容
  15. 如果内容是空，得到是空的中括号 []
  16.  */
  17. public class Demo01ArrayList {
  18.     public static void main(String[] args) {
  19.         //创建了一个ArrayList集合，集合的名称是list，里面装的全部都是String类型的数据
  20.         //备注：从JDK1.7+开始，右侧的尖括号内部可以不写内容，但是<>本身还是要写的
  21.         ArrayList<String> list = new ArrayList<>();
  22.         System.out.println(list);   //[]
  23.         //向集合当中添加一些数据需要用到add方法
  24.         list.add("LILI");
  25.         list.add("OPOP");
  26. //        list.add(100)   ----错误写法
  27.         System.out.println(list);   //[LILI, OPOP]
  28.     }
  29. }

ArrayList集合的常用方法和遍历集合

  1. package com.Demo03;
  3. import java.util.ArrayList;
  5. /*
  6. ArrayList当中的常用方法有：
  7. public boolean add(E e){}：向集合当中添加元素，参数的类型和泛型一致，返回值是布尔值（添加的操作是否成功）
  8. 【备注】：对于ArrayList集合来说，添加的操作一定是成功的，所以一返回值可用可不用；
  9. 但是对于其他集合（今后学习），add添加操作不一定成功
  10. public E get(int Index){}：向集合当中获取元素，参数是索引编号，返回值就是对应的位置值
  11. public E remove(int Index){}：从集合当中删除元素，参数是索引编号，返回值就是被删除的元素
  12. public int size()：获取元素的尺寸长度，返回值就是集合中包含的元素个数
  13.  */
  14. public class Demo02ArrayList {
  15.     public static void main(String[] args) {
  16.         ArrayList<String> list = new ArrayList<>();
  17.         System.out.println(list);   //[]
  18.         //向集合中添加元素：add
  19.         boolean success =list.add("huahua");
  20.         System.out.println(list);    //[huahua]
  21.         System.out.println("添加的操作是否成功："+success);   //true
  22.         //从集合中获取元素：get，索引值从0开始
  23.         list.add("yuanyuan");
  24.         System.out.println("此时list的值是："+list);
  25.         String name=list.get(1);   //yuanyuan
  26.         System.out.println("第1号索引位置："+name);
  27.         //从集合中删除元素：remove，索引值从0开始
  28.         String one=list.remove(0);  //huahua
  29.         System.out.println("被删除的人是："+one);
  30.         System.out.println("删除之后list的值："+list);
  31.         //获取集合的长度：size
  32.         int size=list.size();
  33.         System.out.println("集合的长度："+size);
  34.     }
  35. }

遍历集合

  1. package com.Demo03;
  3. import java.util.ArrayList;
  5. public class Demo03ArrayList {
  6.     public static void main(String[] args) {
  7.         ArrayList<String> list =new ArrayList<>();
  8.         list.add("A");
  9.         list.add("B");
  10.         list.add("C");
  11.         list.add("D");
  12.         //遍历集合
  13.         for (int i=0;i<list.size();i++){
  14.             System.out.println(list.get(i));
  15.         }
  16.     }
  17. }

ArrayList存储基本数据

  1. package com.Demo03;
  3. import java.util.ArrayList;
  5. /*
  6. 如果希望向集合ArrayList当中存放基本数据类型，必须使用基本数据类型对应的“包装类”
  8. 基本类型    包装类（引用类型，包装类都位于java.lang下）
  9. byte        Byte
  10. short       Short
  11. int         Integer
  12. long        Long
  13. float       Float
  14. double      Double
  15. char        Character
  16. boolean     Boolean
  18. 从JDK1.5+开始，支持自动装箱、自动拆箱
  19. 自动装箱：基本类型--->包装类型
  20. 自动拆箱：包装类型--->基本类型
  21.  */
  22. public class Demo04ArrayList {
  23.     public static void main(String[] args) {
  24.         ArrayList<String> listA = new ArrayList<>();
  25. //        ArrayList<int> listB = new ArrayList<int>();  ---错误写法
  26.         ArrayList<Integer> listB = new ArrayList<>();
  27.         listB.add(100);
  28.         listB.add(200);
  29.         System.out.println(listB);  //[100,200]
  30.         int num=listB.remove(1);
  31.         System.out.println("删除的数据为："+num);
  32.     }
  33. }

练习

题目一：生成6个1-33之间的随机整数，添加到集合并遍历集合

  1. package com.Demo03;
  3. import java.util.ArrayList;
  4. import java.util.Random;
  6. public class Demo05ArrayListWork {
  7.     public static void main(String[] args) {
  8.         Random r=new Random();
  9.         ArrayList<Integer> listA = new ArrayList<>();
  10.         int i =1;
  11.         //生成集合
  12.         while (i<=6){
  13.             int num = r.nextInt(32)+1;
  14.             listA.add(num);
  15.             i++;
  16.         }
  17.         System.out.println("生成的集合为："+listA);
  18.         //遍历集合
  19.         for(int j=0;j<listA.size();j++){
  20.             System.out.println("第"+j+"个元素为："+listA.get(j));
  21.         }
  22.     }
  23. }

题目二：自定义4个学生对象，添加到集合中，并遍历

  1. package com.Demo03;
  3. import java.util.ArrayList;
  5. public class Demo05ArrayListWork01 {
  6.     public static void main(String[] args) {
  7.         ArrayList<Student> list = new ArrayList<>();
  8.         Student one = new Student("lili",15);
  9.         Student two = new Student("huhu",19);
  10.         Student three = new Student("keke",25);
  11.         list.add(one);
  12.         list.add(two);
  13.         list.add(three);
  14.         //遍历集合
  15.         for (int i = 0; i < list.size(); i++) {
  16.             Student stu = list.get(i);
  17.             System.out.println("姓名："+stu.getName()+",年龄："+stu.getAge());
  18.         }
  19.     }
  20. }

题目二：定义以指定格式打印集合的方法(ArrayList类型作为参数)，使用{}括起集合，使用@分隔每一个元素，格式参照{元素@元素@元素}

  1. package com.Demo03;
  3. import java.util.ArrayList;
  5. /*
  6. 定义以指定格式打印集合的方法(ArrayList类型作为参数)，使用{}括起集合，
  7. 使用@分隔每一个元素，格式参照{元素@元素}
  8.  */
  9. public class Demo05ArrayListWork02 {
  10.     public static void main(String[] args) {
  11.         ArrayList<String> list = new ArrayList<>();
  12.         list.add("A");
  13.         list.add("B");
  14.         list.add("C");
  15.         printArrayList(list);
  16.     }
  17.     /*
  18.     定义方法的三要素：
  19.     返回值类型：只是进行打印而已，没有运算，没有结果，只用void
  20.     方法名称：printArrayList
  21.     参数列表：ArrayList
  22.      */
  23.     public static void printArrayList(ArrayList<String> list){
  24.         System.out.print("{");
  25.         for (int i = 0; i < list.size(); i++) {
  26.             System.out.print(list.get(i));
  27.             if(i==list.size()-1){
  28.                 System.out.println("}");
  29.             }else{
  30.                 System.out.print("@");
  31.             }
  32.         }
  33.     }
  34. }

题目三：用一个大集合存入20个随机数字，然后筛选其中的偶数元素，放到小集合中，要求使用自定义的方法进行筛选

  1. package com.Demo03;
  3. /*
  4. 分析：
  5. 1.需要创建一个大集合，用来存储int数字，<Integer>
  6. 2.随机数字用Random nextInt
  7. 3.循环20次，把随机数字放入大集合，for循环、add方法
  8. 4.定义一个方法，用来进行筛选
  9. 筛选：根据大集合，筛选符合条件的元素，得到小集合
  10. 三要素：
  11. 返回类型：ArrayList小集合（里面元素个数不确定）
  12. 方法名称：getSmallList
  13. 参数列表：ArrayList大集合（装着20个随机数字）
  14. 5.判断（if）是偶数：num%2==0
  15. 6.如果是偶数，就放到小集合中，否则就不放
  16.  */
  18. import java.util.ArrayList;
  19. import java.util.Random;
  21. public class Demo05ArrayListWork03 {
  22.     public static void main(String[] args) {
  23.         ArrayList<Integer> bigList = new ArrayList<>();
  24.         Random r= new Random();
  25.         for (int i = 0; i < 20; i++) {
  26.             int randomNum=r.nextInt(100)+1;
  27.             bigList.add(randomNum);
  28.         }
  29.         System.out.println(bigList);
  30.         ArrayList<Integer> smallList=getSmallList(bigList);
  31.         System.out.println("小集合中的元素个数为："+smallList.size());
  32.         System.out.println(smallList);
  33.     }
  34.     //整改方法接收大集合参数，返回小集合结果
  35.     public static ArrayList<Integer> getSmallList(ArrayList<Integer> bigList){
  36.         //创建一个小集合 用来装筛选结果
  37.         ArrayList<Integer> smallList = new ArrayList<>();
  38.         for (int i = 0; i < bigList.size(); i++) {
  39.             if (bigList.get(i)%2==0){
  40.                 smallList.add(bigList.get(i));
  41.             }
  42.         }
  43.         return smallList;
  44.     }
  45. }