ArrayList

数组有一个缺点，一旦创建，程序运行期间长度不可以发生改变。但是集合的长度可以改变。因此我们需要学习如何使用集合类，请看以下实例。

public class Person {
 private String name;
 private int age;
 public Person() {
  super();
  // TODO Auto-generated constructor stub
 }
 public Person(String name, int age) {
  super();
  this.name = name;
  this.age = age;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public int getAge() {
  return age;
 }
 public void setAge(int age) {
  this.age = age;
 }
}

/*
 * 题目：定义一个数组，用来存储3个Person对象。
 * 数组有一个缺点，一旦创建，程序运行期间长度不可以发生改变。
 */
public class Demo01Array {
 public static void main(String[] args) {
  Person[] array = new Person[3];
  Person one = new Person("莉莉", 20);
  Person two = new Person("Li莉", 10);
  Person three = new Person("lili", 30);
  //将one当中的地址值赋值到数组的0号元素位置
  array[0] = one;
  array[1] = two;
  array[2] = three;
  System.out.println(array[0]);
  System.out.println(array[1]);
  System.out.println(array[2]);
  System.out.println(array[1].getName());
 }
}

import java.util.ArrayList;
/*
 * 数组的长度不可以发生改变
 * 但是ArraList的长度是可以发生改变的
 * 对于ArrayList来说,<>代表泛型，装在集合当中的所有元素，全都是统一的什么类型，泛型只能是引用类型，不能是基本类型。
 * 对于ArrayList集合来说，直接打印得到的不是地址值，而是内容
 * 如果内容是空，得到的是空的中括号，[]
*/
public class Demo02ArrayList {
 public static void main(String[] args) {
  //创建了一个ArrayList集合，里面的数据全是String类型
  ArrayList<String> list = new ArrayList<>();
  System.out.println(list);//[]
  //向集合当中添加数据，使用add方法
  list.add("李华");
  System.out.println(list);
  list.add("李梅");
  list.add("李梅");
  list.add("李梅");
  list.add("李梅");
  System.out.println(list);
//  list.add(100);//错误，泛型已经说明是字符串，添加进去的元素必须是字符串才行。
 }
}

import java.util.ArrayList;
/*
 * ArrayList当中的常用方法：
 * public boolean add(E e),向集合当中添加元素，参数的类型和泛型一致。
 * 对于ArrayList集合来说，add添加动作一定是成功的，所以返回值可用可不用。
 * public E get(int index),从集合当中获取元素，参数是所以编号，返回值就是对应位置的元素
 * public E remove(int index),从集合当中删除元素，参数是索引编号，返回值就是被删除掉的元素
 * public int size(),获取集合的尺寸长度，返回值就是集合当中包含的元素个数。
 */
public class Demo03ArrayListMethod {
 public static void main(String[] args) {
  ArrayList<String> list = new ArrayList<>();
  System.out.println(list);
  //向集合中添加元素
  boolean success = list.add("刘星");
  System.out.println(list);
  System.out.println("添加的动作是否成功：" + success);
  list.add("流星");
  list.add("彗星");
  System.out.println(list);
  //从集合中获取元素，get，索引值从0开始
  System.out.println("第二号索引位置元素：" + list.get(2));
  //从集合中删除元素，remove，索引值从0开始
  String whoRemoved = list.remove(2);
  System.out.println("被删除的是：" + whoRemoved);
  System.out.println(list);
  //获取集合的长度尺寸，也就是其中的元素个数
  int size = list.size();
  System.out.println("集合的长度是：" + size);
 }
}

遍历集合中的元素：

import java.util.ArrayList;
public class Demo04ArrayListEach {
 public static void main(String[] args) {
  ArrayList<String> list = new ArrayList<>();
  list.add("小王");
  list.add("小李");
  list.add("小刘");
  list.add("小张");
  //遍历集合
  for(int i = 0; i < list.size(); i++) {
   System.out.println(list.get(i));
  }
 }
}

关于泛型：

import java.util.ArrayList;
/*
 * 如果希望向集合ArrayList当中存储基本类型数据，必须使用基本类型对应的“包装类”。
 * 基本类型 包装类（引用类型，包装类都位于java.lang包下）
 * byte  Byte
 * short Short
 * int  Integer【特殊】
 * long  Long
 * float Float
 * double Double
 * char  Character【特殊】
 * boolean Boolean
 * 从JDK1.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("第一号元素是：" + num);
 }
}

相关练习：

import java.util.ArrayList;
import java.util.Random;
/*
 * 题目：生成6个1~33之间的随机数字，添加到集合，并遍历集合。
 */
public class Demo01ArrayListRandom {
 public static void main(String[] args) {
  ArrayList<Integer> list = new ArrayList<>();
  Random r = new Random();
  for(int i = 0; i < 6; i++) {
   int num = r.nextInt(33) + 1;
   list.add(num);
  }
  //遍历集合
  for (int i = 0; i < list.size(); i++) {
   System.out.println(list.get(i));
  }
 }
}

import java.util.ArrayList;
/*
 * 题目：定义以指定格式打印集合的方法
 * 格式：{*元素*元素*元素}
 */
public class Demo02ArrayListPrint {
 public static void main(String[] args) {
  ArrayList<String> list = new ArrayList<>();
  list.add("夏莉");
  list.add("夏利");
  list.add("夏丽");
  list.add("夏历");
  System.out.println(list);
  printArrayList(list);
 }
 public static void printArrayList(ArrayList<String> list) {
  System.out.print("{");
  for (int i = 0; i < list.size(); i++) {
   String name = list.get(i);
   if(i == list.size()-1) {
    System.out.print(name + "}");
   }else {
    System.out.print(name + "*");
   }
  }
 }
}

import java.util.ArrayList;
/*
 * 题目：自定义4个学生对象，添加到集合，并遍历。
 */
public class Demo02ArrayListStudent {
 public static void main(String[] args) {
  ArrayList<Student> list = new ArrayList<>();
  Student one = new Student("小明", 12);
  Student two = new Student("小李", 17);
  Student three = new Student("小华", 14);
  Student four = new Student("小莉", 13);
  list.add(one);
  list.add(two);
  list.add(three);
  list.add(four);
  //遍历集合
  for (int i = 0; i < list.size(); i++) {
   Student stu = list.get(i);
   System.out.println("姓名：" + stu.getName() + ", 年龄：" + stu.getAge());
  }
 }
}

public class Student {
 private String name;
 private int age;
 public Student() {
  super();
  // TODO Auto-generated constructor stub
 }
 public Student(String name, int age) {
  super();
  this.name = name;
  this.age = age;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public int getAge() {
  return age;
 }
 public void setAge(int age) {
  this.age = age;
 }
}

import java.util.ArrayList;
import java.util.Random;
/*
 * 题目：用一个大集合存入20个数字，然后筛选其中的偶数元素，放到小集合当中。
 * 使用自定义的方法来进行筛选。
 */
public class Demo04ArrayListReturn {
 public static void main(String[] args) {
  ArrayList<Integer> bigList = new ArrayList<>();
  Random r = new Random();
  for (int i = 0; i < 20; i++) {
   int num = r.nextInt(100) + 1;
   bigList.add(num);
  }
  ArrayList<Integer> smallList = getSmallList(bigList);
  System.out.println("偶数总共有：" + smallList.size() + "个。");
  for (int i = 0; i < smallList.size(); i++) {
   System.out.println(smallList.get(i));
  }
 }
 // 接收大集合参数，返回小集合结果
 public static ArrayList<Integer> getSmallList(ArrayList<Integer> bigList) {
  ArrayList<Integer> smallList = new ArrayList<>();
  for (int i = 0; i < bigList.size(); i++) {
   int num = bigList.get(i);
   if (num % 2 == 0) {
    smallList.add(num);
   }
  }
  return smallList;
 }
}