List Set Map接口知识点归纳

接口 List

1.实现类ArrayList数组   LinkedList连表
2.顺序与加入顺序相同
3.手动排序: 前提list中元素类必须是实现了Comparable接口,即前提是list中元素类有排序规则 
   Collections.sort(list);
   Collections.reverse(list);
   Collections.shuffle(list);
4.无素可重复
5.可加入任何元素

package com.fs.test;

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

public class PeopleList {

	/**
	 * @param args
	 */
	public void m1() {
		List<People> list = new ArrayList<People>();
		list.add(new People("ss",11));
		list.add(new People("jj",13));
		list.add(new People("kk",12));
		list.add(new People("dd",11));
		list.add(new People("ll",13));
		list.add(new People("ff",12));
		list.add(new People("aa",11));
		list.add(new People("gg",13));
		list.add(new People("hh",12));
		
		System.out.println(" -------- 正序  -------- ");
		Collections.sort(list);// 正序
		for (People people : list) {
			System.out.println(people);
		}
		
		System.out.println(" -------- 倒序  -------- ");
		Collections.reverse(list);// 倒序
		for (People people : list) {
			System.out.println(people);
		}
		
		System.out.println(" -------- 乱序  -------- ");
		Collections.shuffle(list);// 乱序
		for (People people : list) {
			System.out.println(people);
		}
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		PeopleList s1 = new PeopleList();
		s1.m1();
	}

}

 

package com.fs.test;

public class People implements Comparable<People> {
	private String name;
	private Integer age;
	
	@Override
	public String toString() {
		return "People [name=" + this.name + ", age=" + this.age + "]";
	}

	public People() {
		super();
		// TODO Auto-generated constructor stub
	}

	public People(String name, Integer age) {
		super();
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Integer getAge() {
		return age;
	}

	public void setAge(Integer age) {
		this.age = age;
	}

	@Override
	public int compareTo(People people) {
		// TODO Auto-generated method stub
		int r = this.getAge() - people.getAge();//3 - 1
		if(r>0) {// 如果把return 1 和 -1 的位置对换,则 sort 正序 也能变倒序. reverse 同理.
			return 1;
		}else if(r<0) {
			return -1;
		}else {
			return this.getName().compareTo(people.getName()); 
		}
	}
}

 

接口Set
1.实现类 HashSet较快   TreeSet较慢
2.Set中无素不可重复
3.HashSet中顺序不可控，TreeSet顺序与加入顺序无关，与无素内容有关，自动按元素内容来排序
4.HashSet中可加入任何元素，但是TreeSet中加入的元素必须是实现了Comparable接口,即前提是TreeSet中元素类有排序规则

 

package com.fs.test;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

public class Test {
	private void show(Set<String> set) {
		Iterator<String> it = set.iterator();
		while (it.hasNext()) {
			String str = it.next();
			System.out.println(str);
		}
	}

	private void show2(Set<String> set) {
		for (String s : set) {
			System.out.println(s);
		}
	}

	// HashSet
	private void m1() {
		Set<String> set = new HashSet<String>();
		set.add("aa");
		set.add("bb");
		set.add("cc");
		set.add("cc");
		set.add("dd");
		set.add("dd");
		set.add("ee");
		set.add("ff");
		this.show2(set);
	}

	private void m2() {
		Set<Teacher> set = new HashSet<Teacher>();
		set.add(new Teacher("aa", 2));
		set.add(new Teacher("aa", 2));
		set.add(new Teacher("bb", 3));
		set.add(new Teacher("dd", 4));
		for (Teacher teacher : set) {
			System.out.println(teacher.toString());
		}
	}

	// TreeSet
	private void m3() {
		Set<String> set = new TreeSet<String>();
		set.add("cc");
		set.add("dd");
		set.add("dd");
		set.add("ee");
		set.add("ff");
		set.add("aa");
		set.add("bb");
		set.add("cc");
		this.show2(set);
	}
	private void m4() {
		Set<Teacher> set = new TreeSet<Teacher>();
		set.add(new Teacher("bb", 3));
		set.add(new Teacher("aa", 2));
		set.add(new Teacher("aa", 2));
		set.add(new Teacher("dd", 4));
		System.out.println(set.size());
		for (Teacher teacher : set) {
			System.out.println(teacher.toString());
		}
	}

	public static void main(String[] args) {
		Test t = new Test();
		t.m4();
	}
}

 

package com.fs.test;

public class Teacher implements Comparable<Teacher> {
	private String name;
	private int age;
	
	@Override
	public String toString() {
		String inf = "name:"+this.name+",age:"+this.age;
		return inf;
	}
	
	public Teacher(String name, int age) {
		this.name = name;
		this.age = age;
	}
	public Teacher() {
		
	}
	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 int compareTo(Teacher o) {
		int r = this.getAge() - o.getAge();
		if(r>0) {
			return -1;
		}else if(r<0) {
			return 1;
		}else {
			return 0;
		}
	}
}

 

 

接口Map
1.实现类HashMap较快、 TreeMap较慢
2.Map中键不会重复,,当键重复时,将用后来值代替原有值.
3.HashMap可加入任可键值对，顺序不可控
4.TreeMap加入的键值对中的键有前提条件，键的类必须是实现了Comparable接口
5.TreeMap中顺序，按键来排序.