JAVA集合框架-List

看 黑马java 视频 笔记

Collection:

    |--  List  元素是有序的，元素有重复，因为元素都具有索引

       -----ArrayList    底层的数据结构使用的是数组结构    查询速度快，但增删慢   线程不同步

     -------LinkedList   底层的数据结构使用的是链表结构   查询速度慢  但增删快

    --------Vector     底层的数据结构是数组结构   线程同步

    |---Set

迭代器的使用：

 private static void method_get() {

<pre name="code" class="java">		// 迭代器的使用
		ArrayList<Object> al = new ArrayList<Object>();
		// 增加元素 add方法的参数类型是Object，一边接胡搜任何类型.
		al.add("liqw");
		al.add("qingdaji");
		al.add("xiaopao");
		al.add("dabing");

		Iterator<Object> iterator = al.iterator();// 用迭代器取出集合中的元素
		while (iterator.hasNext()) {
			show(iterator.next());
		}

	}

在是用迭代器过程中，我们想对已查找到的元素进行修改，此时却发现有异常，官方文档的解释：

当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。

例如，某个线程在 Collection 上进行迭代时，通常不允许另一个线性修改该 Collection。通常在这些情况下，迭代的结果是不确定的。如果检测到这种行为，一些迭代器实现（包括 JRE 提供的所有通用 collection 实现）可能选择抛出此异常。执行该操作的迭代器称为快速失败 迭代器，因为迭代器很快就完全失败，而不会冒着在将来某个时间任意发生不确定行为的风险。

迭代器正在操作元素的过程中，有用到了集合的方法对此操作，故会报异常

解决办法：1.利用集合的方法对元素增删改查

                     2.利用迭代器的方法对元素进行增删改查

但发现，Iterator的方法有限，故引出了线性迭代器 ListIterator

用ListIterator 方法遍历，修改

		ListIterator<Object> iterator = al.listIterator();
		while (iterator.hasNext()) {
			Object obj = iterator.next();
			if (obj.equals("liqw")) {
				iterator.add("hello");
			}
		}

Arraylist自定义比较器equals

import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;

class Person {
	private String name;
	private int age;

	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}

	// list集合判断元素是否相等，实际调用的是equal方法
	public boolean equals(Object obj) {

		if (!(obj instanceof Person)) {
			return false;
		}
		Person p = (Person) obj;
		System.out.println(this.name + "......" + p.getName());
		// System.out.println(p.getName());
		return this.name == p.getName() && this.age == p.getAge();

	}

	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;
	}
}

public class ArrayListText {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ArrayList<Object> list = new ArrayList<Object>();
		Person Daji = new Person("daji", 20);
		Person Dabing = new Person("dabing", 23);
		Person Dabing2 = new Person("dabing", 23);
		Person Dabing3 = new Person("dabing", 23);

		list.add(Daji);
		list.add(Dabing);
		list.add(Dabing2);
		list.add(Dabing3);

		list = singleElement(list);
		Iterator<Object> iterator = list.iterator();
		while (iterator.hasNext()) {
			Person p = (Person) iterator.next();
			show("name is " + p.getName() + "....." + "the age is "
					+ p.getAge());
		}

	}

	private static void show(Object obj) {
		// TODO Auto-generated method stub
		System.out.println(obj);
	}

	private static ArrayList<Object> singleElement(ArrayList<Object> list) {

		ListIterator<Object> iteratot = list.listIterator();
		ArrayList<Object> newlist = new ArrayList<Object>();

		while (iteratot.hasNext()) {
			Object obj = iteratot.next();
			if (!newlist.contains(obj)) {
				newlist.add(obj);

			}
		}
		return newlist;

	}

}

HashSet 

/*
 * Set元素是无序的，存入和取出的顺序不一定一致，元素不可以重复
 * 
 * HashSet 底层数据结构是哈希表
 * HashSet是如何保证元素的唯一性：
 * 通过元素的两个方法，hashcode 和equals 
 * 如果元素的hasncode值相同，才会判断equals方法
 * 注意：对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法     
 * 
 * 
 * */

	public int hashCode(){
		System.out.println(name+"......hashcode....."+age);
		return name.hashCode()+age*37;
		
	}

	// list集合判断元素是否相等，实际调用的是equal方法
	public boolean equals(Object obj) {

		if (!(obj instanceof Person)) {
			return false;
		}
		Person p = (Person) obj;
		System.out.println(this.name + "...equals..." + p.getName());
		return this.name == p.getName() && this.age == p.getAge();

	}

TreeSet: /*
 * TreeSet可以对set集合中的元素进行排序，按照字母的自然顺序

                底层数据结构是二叉树，保证元素唯一的依据是：

              compareto方法， return0 

                TreeSet排序的第一种方式：让元素自身具备比较性，元素实现comparable接口，覆盖compareto方法

                这种方法也成为自然排序，或者默认排序。
 * 
 * 排序时，当主要条件相同时，一定要判断次要排序。
 * */

class Student implements Comparable<Object> { // 该接口强制使学生具有比较性

	private String name;
	private int age;

	public Student(String name, int age) {
		this.setName(name);
		this.setAge(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 int compareTo(Object obj) {

		if (!(obj instanceof Student))
			throw new RuntimeException("不是学生");

		Student s = (Student) obj;

		System.out.println(this.getAge() + "..compare to....." + s.getAge());

		if (this.getAge() > s.getAge())
			return 1;
		if (this.getAge() == s.getAge()) {

			return this.getName().compareTo(s.getName());
		}

		else
			return -1;
	}
}

         treeSet元素的第二种排序方式：

            当元素自身不具备比较性，或者具备的比较性不是所需的，这是就需要让集合自身具有比较性。
          让集合初始化时，就具有比较性

class MyComparetor implements Comparator<Object> {

	@Override
	public int compare(Object o1, Object o2) {
		// TODO Auto-generated method stub
		String s1 = (String) o1;
		String s2 = (String) o2;

		int num = s1.length() - s2.length();

		if (num == 0)
			return s1.compareTo(s2);

		return num;
	}

}