Java基础学习之集合 List

一 集合中的方法

1.addAll   removeAll   retainAll

Collection c1 = new ArrayList();
		c1.add("a");
		c1.add("b");
		c1.add("c");
		c1.add("d");
		Collection c2 = new ArrayList();
		c2.add("a");
		c2.add("b");
		c2.add("c");
		c2.add("y");

1.addAll

public static void fun1添加(Collection c1, Collection c2) {
		// 添加方法
		//把c2当做一个元素 添加到c1中
//		c1.add(c2);   //[a, b, c, d, [a, b, c, y]
		//此时是将c2中每一个元素都添加进c1  
		c1.addAll(c2);
		System.out.println(c1);//[a, b, c, d, a, b, c, y]
	}

2.removeAll

public static void fun删除(Collection c1, Collection c2) {
		//removeAll
		//删除的是调用集合的元素,元素指的是两个集合的交集
	boolean rel =c1.removeAll(c2);
		System.out.println(c1);//[d]
		System.out.println(c2);//[a, b, c, y]
		System.out.println(rel);//true
	}

c1与c2的交集是 a,b,c 故此 c1的最终结果为[d]

3.retainAll

public static void fun3取交(Collection c1, Collection c2) {
		//返回的是两个集合的交集,如果两个集合有交集,就返回true;
		boolean rel = c1.retainAll(c2);
		System.out.println(c1);//a,b,c
		System.out.println(c2);//a,b,c,y
		System.out.println(rel);
	}

二 遍历集合(迭代器)

public static void fun() {
		Collection c = new ArrayList<>();
		
		//实际上 集合内部有个指针指向集合最上
		           //  <-- 1指针  调用next  实际上把指针向下移动一位,调用几次,移动几位.
		c.add("a");//
		c.add("b");//
		c.add("c");//
		c.add("d");//
		//从集合中获取迭代器.
		Iterator iterator = c.iterator();
		//判断是否有下一个元素
	boolean rel	= c.iterator().hasNext();
	
	System.out.println(rel);
	//如果有下一个元素,
	if (rel) {
		for (int i = 0; i < c.size(); i++) {
			System.out.println(iterator.next());
		}

	}
	}

遍历集合时要先判断是否集合中具有下一个元素

public static void fun2() {
		Collection c = new ArrayList<>();
		c.add("a");//
		c.add("b");//
		c.add("c");//
		c.add("d");//
		//从集合中获取迭代器.
				Iterator iterator = c.iterator();
				//循环
				while (iterator.hasNext()) {
					// 注意循环中只调用一次next方法
					//获取集合中元素
					Object x= iterator.next();
					//打印集合元素
					System.out.println(x);
				}
	}

list 中的方法

1.ArrayList  和 LinkedList 的区别

1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。 
 2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。 

 3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。

  ArrayList 特点
     数组实现: 查询按角标, 增删时式是把要删除或增加的元素 后面的所有元素

    向前移动或者向后移动

linkedList 特点
     查询慢 增删快
     链表实现: 查询时,系统会先看这个元素离链表的最近端开始查找.  
     增删时 链表的元素 要保证能找到自己上一个和下一个元素,需要保存地址,就能

    找到元素位值,就相当于插入到了链中,链中其他元素地址不会改变

2.

 add(int index,Object obj)
 set(index,obj)
 get(int index)
 remove(int index)

public static void fun1() {
		List list = new ArrayList<>();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		//添加(不要超出集合的元素个数)
		list.add(4,"x")//.......
		// 设置元素(替换该位置的元素)
		list.set(1, "w");
		//获取下标处的元素
		Object object =list.get(2);
		// 删除(返回的是删除的元素)
		Object obj=	list.remove(2);
		System.out.println(obj);
		stem.out.println(object);
		//利用get方法遍历集合
		for (int i = 0; i < list.size(); i++) {
			Object object1 =list.get(i);
			System.out.println(object1);
		}

public static void fun2() {
		List list = new ArrayList<>();
		list.add(111);
		list.add(222);
		list.add(333);
		//删除111
		//list.remove(111);//系统会把111 当成角标处理,没有自动装箱
		list.remove(0);
		
		System.out.println(list);
	}

要注意的是remove() 括号里可以填具体元素 也可以填集合索引值, 当集合为数字时 系统不会自动装箱,会把具体的数值元素当成索引值.

vector 的遍历

public static void fun3() {
		//vector 创建一个
		Vector vector = new Vector<>();
		vector.addElement("a");
		vector.addElement("b");
		vector.addElement("c");
		vector.addElement("d");
		vector.addElement("e");
		vector.addElement("f");
		
		//遍历集合
	Enumeration e = vector.elements();
		
		while (e.hasMoreElements()) {
			System.out.println(e.nextElement());
		}
	}

list 中特有的迭代器

List list  = new ArrayList<>();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");

1.采用 Iterator 迭代器遍历时添加元素

public static void fun错误添加(List list ) {
		Iterator it = list.iterator();
		//原有长度4 迭代器就按照原有长度进行迭代
		while (it.hasNext()) {
			String ob =(String)it.next();
			//java.util.ConcurrentModificationException  
			//并发修改异常
			if (ob.equals("b")) {
				// 修改了集合的原有长度
				//解决:让迭代器去进行添加的操作  调用迭代器中的添加方法
				list.add("Oh-Yes");
			}
		}

上面的迭代器遍历时集合长度已定,无法进行添加的操作

//使用list 中特有的迭代器 ListIterator
		//创建迭代器
		ListIterator listIterator = list.listIterator();
		while (listIterator.hasNext()) {
			//获取元素并强转型
			String string = (String)listIterator.next();
			if (string.equals("b")) {
				listIterator.add("Oh-Yes"); 
			}
		}
		System.out.println(list);
	}

去重:

public static void fun去重() {
		//  需求 在集合中存储 "a""a""a" "b""b""b" "c""c""c"
		//  要求 去除重复元素
			List list = new ArrayList();
			list.add("a");
			list.add("a");
			list.add("a");
			list.add("b");
			list.add("b");
			list.add("b");
			list.add("c");
			list.add("c");
			list.add("c");
			//创建新数组
			List  newlist = new ArrayList<>();
			//迭代器
			Iterator  lt  = list.iterator();
			while (lt.hasNext()) {
				String st = (String)lt.next();
				//判断新集合里是否包含了老集合中的元素
				if (!newlist.contains(st)) {
					newlist.add(st);
				}
				
			}
			System.out.println(newlist);
	}

再看下面一个例子

	//  需求 在集合中存储 6个学生
		//  分别 两个 彭 18岁  两个坤 16岁 两个峰 80岁
		//  去除重复的

1.先建立一个学生类

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;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
	

2.添加元素并去重

List list = new ArrayList<>();
			list.add(new Student("彭",18));
			list.add(new Student("彭",18));
			list.add(new Student("坤",16));
			list.add(new Student("坤",16));
			list.add(new Student("峰",80));
			list.add(new Student("峰",80));
			List newlist = new ArrayList<>();
			
			Iterator it = list.iterator();//迭代器
			while (it.hasNext()) {
				Student sd = (Student)it.next();
				// 判断 ,这段代码去重依赖的是 contains  
				// contains 方法中依赖的是 equals方法 对比的是元素的地址 ,每一个student 创建的地址都不一样所以去重失败
				// 只要是学生 名字和年龄相同
				if (!newlist.contains(sd)) {
					newlist.add(sd);
				}
			}
			System.out.println(newlist);

如上,此时,

(!newlist.contains(sd);

无法进行判断 ,所以我们想到在student类中重写 equals方法,直接比较 字符串 name 与int  age.

@Override
	public boolean equals(Object obj) {
		Student student = (Student)obj;
		// 直接重写equals方法 的规则  直接比姓名年龄都相等.
		return this.name.equals(student.getName())&&this.age==student.getAge();
	}

此刻比较的是 name 与age 两者被不被包含时 将student 移入新集合.