Java学习笔记（29）-Collection框架及List集合

Collection是集合的顶级父类：是一个接口

其下有两个子类：List和Set

List：元素可重复。  List都是有序的

Set：元素不可重复。  Set大部分是无序的

List中存放的数据equals为true的，可以都存放

Set中存放的数据equals都为false

List:可重复集的父接口

其有两个常用的子类实现：

ArrayList和LinkedList。

package day02;

import java.awt.List;
import java.util.ArrayList;

/**
 * List(线性表)
 * List本身不能实例化！我们可以使用其几个子类实现
 * @author Administrator
 *
 */
public class DemoList {
	public static void main(String[] args) {
		/**
		 * 创建一个ArrayList实例
		 * List和ArrayList均处于java.util包下
		 * 使用List我们不需要在创建的时候考虑容量。
		 * 集合的容量是根据其所保存的元素决定的。
		 * 换句话说，集合的容量是可以自动扩充的。
		 */
		ArrayList list = new ArrayList();
		/**
		 * add方法，向集合末尾追加一个新元素
		 * add(Object obj).
		 * 从该方法的参数定义不难看出，集合可以存放任意类型的元素
		 * 但在实际编程中我们发现，几乎不会向集合中存放一种以上不同类型的元素。
		 */
		list.add("One");//向集合中添加一个字符串。
		list.add("Two");
		list.add("Three");
		//不建议这样的操作！尽量不在同一个集合中存放不同类型元素
//		list.add(1);
		System.out.println("集合中的元素数量："+list.size());
		/**
		 * ArrayList同样重写了toString()方法。
		 * 返回的字符串是每个元素的toString()返回值的序列
		 */
		System.out.println(list.toString());//list
		//清空集合
		list.clear();
		System.out.println("清空后集合元素数量："+list.size());
		System.out.println("集合是空的吗？"+list.isEmpty());
	}
}

package day02;

public class Point {
	private int x;
	private int y;
	public Point(int x,int y){
		this.x = x;
		this.y = y;
	}
	public String toString(){
		/*
		 * 重写toString方法，返回的字符串用于描述当前对象
		 * 这个对象保存的 是一个点的信息，所有告知外接x,y的坐标
		 */
		return "x="+x+",y="+y;
	}
	/*
	 * 重写Object继承过来的该方法，用于定义对象内容比较规则
	 */
	public boolean equals(Object obj){
		/*
		 * 若给定的对象obj的地址和当前对象地址一致，那么他们是
		 * 同一个对象，equals肯定要返回true！自己一定像自己！
		 * 当我们在equals方法中有大量的内容比较逻辑时，加上这个判断
		 * 会节省性能的开销!
		 * 
		 */
		/*
		 * equals比较前要进行安全验证，确保给定的对象不是null!
		 * obj若是null，说明该引用变量没有指向任何对象。那么就不能
		 * 引用obj所指向的对象（因为对象不存在）的属性或方法！
		 * 若这么做就会引发NullPointerException，空指针异常！
		 */
		if(obj==null){
			return false;
		}
		/*
		 * 直接将Object转为子类是存在风险的！
		 * 我们不能保证Object和我们要比较的对象是同一个类型的
		 * 这会引发ClassCastException！我们称为类造型异常
		 */
		//重写equals时第一件要做的事情就是判断给定的对象是否和当前
		//对象为同一个类型。不是同类型直接返回false，不具备可比性。
		if(!(obj instanceof Point)){//不是这个类型的实例
			return false;
		}
		Point p = (Point)obj;
		/*
		 * 内容比较逻辑定义。
		 */
		return this.x==p.x && this.y == p.y;
	}
	public static void main(String[] args) {
		/*
		 * main方法是静态方法
		 * 不能直接使用toString()方法，因为该方法不是静态的
		 * java语法规定：
		 * 静态方法中不能直接引用非静态的属性和方法！
		 * 非静态方法中可以直接引用静态属性和方法
		 */
//		System.out.println(toString);//不行！编译错误！
		Point p = new Point(6,6);
		System.out.println(p);//输出p对象的toString方法返回值
	}
}

package day02;

import java.util.ArrayList;
import java.util.List;

/**
 * 测试ArrayList
 * @author Administrator
 *
 */
public class DemoList2 {
	public static void main(String[] args) {
		//多态的写法
		List list = new ArrayList();
		//正常的写法
//		ArrayList arrayList = new ArrayList();
		//存放三个Point实例到集合中
		list.add(new Point(1,2));
		list.add(new Point(3,4));
		list.add(new Point(5,6));
		
		System.out.println(list);
		//创建一个Point对象
		Point p = new Point(1,2);
		/**
		 * contains(Object obj)方法检查给定对象是否被包含在集合中
		 * 检查规则是将obj对象与集合中每个元素进
		 * 行equals比较
		 * 若equals返回true，则该方法返回true。
		 * 若比对了所以元素均没有equals为true的则返回false
		 */
		System.out.println("p在集合中存在吗？"+list.contains(p));
		/**
		 * 被存放的元素的equals方法在集合中决定的事情还很多！
		 * 是否重写元素的equals方法对集合的操作结果有很大的效果不同
		 */
		/**
		 * 删除一个元素
		 */
		System.out.println("删除前元素数："+list.size());//3
		list.remove(p);//将p对象删除
		System.out.println("删除后元素数："+list.size());//2
		System.out.println(list);
	}
}

package day02;

import java.util.ArrayList;
import java.util.List;

/**
 * ArrayList测试
 * @author Administrator
 *
 */
public class DemoList3 {
	public static void main(String[] args) {
		List list1 = new ArrayList();
		List list2 = new ArrayList();
		List list3 = new ArrayList();
		//为第一个集合添加元素
		list1.add("One");
		list1.add("Two");
		list1.add("Three");
		//为第二个集合添加元素
		list2.add("four");
		list2.add("five");
		//为第三个集合添加元素
		list3.add("One");
		list3.add("Two");
		/**
		 * 将集合2的元素存放到集合1中
		 * 集合的addAll(Collection c)
		 * 该方法允许将c对应的集合中的所有元素存入该集合
		 * 注意，这里的参数为Collection，所有换句话说，任何集合类型都
		 * 可以将其元素存入其他集合中！
		 */
		list1.addAll(list2);//[One,Two,Three,Four,five]
		//从list1中删除list3中相同（equals为true的)元素
		list1.removeAll(list3);;//[Three,four,five]
		//保留list1中与list3中相同(equals为True的)元素
		list1.retainAll(list2);//[four,five]
	}
}

package day02;

import java.util.ArrayList;
import java.util.List;

/**
 * List元素的修改与查询
 * @author Administrator
 *
 */
public class DemoList4 {
	public static void main(String[] args) {
		/**
		 * 想获取集合中的元素我们可以使用get()方法
		 * Object get(int index);
		 * 根据元素下标获取对应位置的元素并返回
		 * 这里元素下标和数组相似。
		 */
		List list = new ArrayList();
		list.add("One");
		list.add("Two");
		list.add("Three");
		//因为get方法是以Object类型返回的元素，所以需要造型
		String element = (String)list.get(2);//获取第三个元素
		System.out.println(element);
		//遍历集合
		for(int i=0;i<list.size();i++){
			System.out.println(list.get(i));
		}
		
		/**
		 * set方法，用于修改集合中的元素
		 * Object set(int index,Object newElement);
		 * 将index位置的元素修改为newElement.修改后会将被修改的元素返回。
		 * 将”three"替换为“三”
		 */
		Object old = list.set(2, "三");
		System.out.println("被替换的元素："+old);
		System.out.println(list); 
		/**
		 * 向集合中插入一个元素
		 * add(int index,Object newElement)
		 * 使用add的重载方法，我们可以向index指定位置插入newElement
		 * 原位置的元素自动向后移动
		 * 所谓的"插队"
		 * 在One Two 与三之间插入一个二
		 *    0  1    2
		 */
		list.add(2,"二");
		System.out.println(list);
		/**
		 * 根据下标删除元素
		 * Object remove(int index)
		 * 将集合中下标为index的元素删除，并将被删除的元素返回
		 */
		Object obj = list.remove(1);
		System.out.println("被删除的元素："+obj);
		System.out.println(list);
	}
}

package day02;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * List中的其他方法
 * @author Administrator
 *
 */
public class DemoList5 {
	public static void main(String[] args) {
		/**
		 * List中也有类似String的方法indexOf，lastIndexOf
		 */
		List list = new ArrayList();
		list.add("One");
		list.add("Two");
		list.add("Three");
		list.add("One");
		System.out.println(list.indexOf("Three"));//2
		System.out.println(list.lastIndexOf("One"));//3最后一次出现的位置
		/**
		 * 如何将一个集合转换为数组？
		 * Object[] toArray()
		 * 该方法会将集合以对象数组的形式返回
		 */
		Object[] array  = list.toArray();
		System.out.println(Arrays.toString(array));
	}
}

package day02;

import java.util.ArrayList;
import java.util.List;

/**
 * 集合的toArray()
 * @author Administrator
 *
 */
public class DemoList6 {
	public static void main(String[] args) {
		List list = new ArrayList();
		list.add(new Point(1,2));
		list.add(new Point(2,3));
		list.add(new Point(4,5)); 
		/**
		 * toArray的重载方法，可以很方便的让我们转换出实际的数组类型
		 * 参数的作用是作为返回值数组的类型，所以参数传入的数组不需要有任何长度，
		 * 因为用不到，就没有必要浪费空间
		 */
//		Object[] array = list.toArray();
		Point[] array = (Point[])list.toArray(new Point[0]);
		for(int i=0;i<array.length;i++){
//			Point p = (Point)array[i];
			Point p = array[i];
			System.out.println(p.getX());
		}
	}
}

package day02;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * 迭代器
 * 用于遍历集合中的元素使用
 * 
 * @author Administrator
 *
 */
public class DemoIterator {
	public static void main(String[] args) {
		List list = new ArrayList();
		list.add("One");
		list.add("#");
		list.add("Two");
		list.add("#");
		list.add("Tree");
		list.add("#");
		/**
		 * iterator()方法
		 * 该方法会返回一个Iterator的实现类实例，用于遍历当前集合
		 * 
		 * Iterator在java.util包下
		 * 其是一个接口，定义了遍历器应有的方法
		 * 不同的集合返回的Iterator不都是同一个子类实现。
		 * 了解即可。
		 * 迭代器的使用方式：先问后拿
		 * 问:boolean hashNext()
		 * 该方法询问迭代器当前集合是否还有元素。
		 * 拿：object next()
		 * 该方法会获取当前元素。
		 * 
		 * 迭代器的迭代方法是为while循环量身定制的
		 */
		Iterator it = list.iterator();
		while(it.hasNext()){//集合中是否还有下一个元素
			String element =(String) it.next();//有就将其取出
			/**
			 * 在迭代器迭代的过程中，我们不能通过集合的增删等操作
			 * 来改变该集合的元素数量！否则会引发迭代异常！
			 */
			if("#".equals(element)){
//				list.remove(element);//不可以！
				/**
				 * 迭代器的remove()方法可以将刚刚获取的元素从集合中删除，但是不能重复调用两次！
				 */
				it.remove();//删除当前位置的元素,没有返回值
			}
			System.out.println(element);
		}
		System.out.println(list);
	}
}

List的其他操作：

    取子集：subList(int fromIndex,int toIndex)

package day03;

import java.util.ArrayList;
import java.util.List;

/**
 * 获取集合子集subList()
 * @author Administrator
 *
 */
public class DemoListSubList {
	public static void main(String[] args) {
		/**
		 * 创建一个集合，向集合中存放0-9的数字
		 * 泛型定义基本类型时使用其包装类。
		 */
		List<Integer> list = new ArrayList<Integer>();
		for(int i=0;i<10;i++){
			list.add(i);
		}
		System.out.println(list);//[0,1,2,3,4,5,6,7,8,9]
		//取子集(3-7)
		List<Integer> subList = list.subList(3,8);
		System.out.println(subList);//[3,4,5,6,7]
		
		/**
		 * 若我们对自己的元素进行修改会不会影响原来的集合？
		 * 注意，我们在获取子集后，若对自己元素进行修改，会影响原来的集合元素。
		 */
		for(int i=0;i<subList.size();i++){
			int element = subList.get(i);
			element*=10;
			subList.set(i,element);
//			subList.set(i, subList.get(i)*10);//等同上面三步
		}
		System.out.println(subList);
		System.out.println(list);//原集合内容也被修改了
		}
}