单列集合（collection）

单列集合（collection）

集合分为单列集合（collection） 和双列集合（Map）
单列集合
	--|list
		--|ArrayList：有序可重复
			ArrayList: 是List接口的一个实现类，类里面封装了一个可变长数组对象
			void add(Object o);尾插法添加元素
			void add(int index, Object o);将对象插入到指定的位置
			Boolean addAll(int index ,Colleation c) 将集合插入到指定下标位置
			Object get(int index);返回集合中下标为index的元素
             Object remove(int index);删除集合中的一个元素
             retain(Collection c);保留两个集合的交集
             removeAll(Collection);删除两个集合的交集
             clear();清空集合
             set(int index, Object o);使用O来替换指定的下标元素
             int size();获取集合中有效元素的个数
             Object[] toArray();把集合中的元素按照object类存入Object[]数组中，展示
             Object get(int index);获取集合，指定下标的元素
             int indexOf();查询指定元素的第一次出现的位置
             int lastIndexOf(Object O);查询指定元素最后一次出现的下标
             List subList(int fromIndex, int toindex); 截取list集合空间（包头不包尾）
             特点：查询效率快，增删效率慢
		--|linkedList
			linkedList:该集合内部存在一个双向循环链表，链表的每一个元素都是通过引用的方式记住前一个元素和后一个元素；从而连接起来，增删的时候只需要改变这种引用关系即可；
			void add(int index, E e);在列表中指定位置插入一个元素
			void addFirst(Object o) ;在列表中首位置添加元素
             void addLast(Object o); 在列表结尾添加元素
             Object getFirst();返回列表中的第一个元素
             Object getLast();返回列表中最后一个元素
             object removeFirst();删除第一个元素
             object removeLast();删除列表最后一个元素
            特点：增删效率快，查询效率慢
		Iterator接口（迭代器）
			Iterator it = c.Iterator();
			boolean hasNext();判断集合是否可以继续迭代
			next();获取当前元素，指向下一个元素
			remove();
			需要注意的迭代器在获取ArrayList元素的时候，是按照Object类型来看待的，如果想特定元素需要强制类型转换
			
	--|set
	   set ： 无序不可重复
	   --|HashSet：根据哈希值来确定元素存储的位置，查询，增删效率快
	   	 hashCode() and equals();
	   --|TreeSet：存在根节点，添加元素时必须有比较元素的方式和方法
	   	 添加到TreeSet集合中的元素有两种方案：
	1. 存在自然顺序，数字 10 20
	2. 实现一些方法！！！
		方案1: Comparable接口	
			实现的方法 int compareTo(Object o);
		方案2：Comparator接口
			实现的方法 int compare(Object o1, Object o2);
	   	
		

ArrayList()集合演示;

import java.util.ArrayList;

public class TestArrayList {

	public static void main(String[] args) {
		ArrayList list = new ArrayList();
		//添加操作
		list.add("小谷");
		list.add("小甜");
		list.add("于齐");
		list.add("小齐");
		list.add("杨森");
		list.add("煜儿");
		//指定位置添加操作
		list.add(2, "猪齐");
		//打印集合操作
		System.out.println(list);
		ArrayList list1 = new ArrayList();
		list.add("猪寒");
		//在集合中添加集合
		list.addAll(list1);
		System.out.println(list);
		//从集合中获取指定下标的值
		System.out.println(list.get(2));	
		//集合中的删除操作（指定小标位置）
		list.remove(2);
		System.out.println(list);
		ArrayList list2 = new ArrayList();
		list2.add("森哥");
		list2.add("龙哥");
		list2.add("小甜");
		list2.add("小谷");
		//删除两个集合的交集
//		list.removeAll(list2);
//		System.out.println(list);
		//保留两个集合的交集
		list.retainAll(list2);
		System.out.println(list);
		//集合清空操作
		list2.clear();
		System.out.println(list2);
		//修改元素
		list.set(0, "韩寒");
		System.out.println(list);
		//元素的个数
		System.out.println(list.size());
		//转换成Object类型数组输出
		Object[] o = list.toArray();
		print(o);
		//输出该元素第一次出现的下标
		System.out.println(list.indexOf("韩寒"));	
		//输出该元素最后一次出现的下标
		System.out.println(list.lastIndexOf("韩寒"));	
		//截取集合（包头不包尾）
		System.out.println(list.subList(0,1));	
		
	}
	//增强for循环
	public static void print(Object[] o) {
			for (Object object : o) {
			System.out.println(object);
		}
			System.out.println();
	}

}

LinkedList()使用演示

import java.util.LinkedList;

public class TestLinkedList {

	public static void main(String[] args) {
		LinkedList lkl = new LinkedList();
		lkl.add("于甜甜");
		lkl.add("于甜猪");
		lkl.add("于甜狗");
		//void add(int index, E e);在列表中指定位置插入一个元素
		lkl.add(0,"于甜猫");
		System.out.println(lkl);
		//void addFirst(Object o) ;在列表中首位置添加元素
		lkl.addFirst("nn");
		System.out.println(lkl);
		//void addLast(Object o); 在列表结尾添加元素
		lkl.addLast("cc");
		System.out.println(lkl);
		//Object getFirst();返回列表中的第一个元素
		System.out.println(lkl.getFirst());
		//Object getLast();返回列表中最后一个元素
		System.out.println(lkl.getLast());
		// object removeFirst();删除第一个元素
		lkl.removeFirst();
        // object removeLast();删除列表最后一个元素
		lkl.removeLast();
		System.out.println(lkl);
		
	}

}

HashSet()

import java.util.HashSet;
import java.util.Set;

public class Demo1 {
	public static void main(String[] args) {
		/*
		 * Set是一个接口，不存在自己的类对象，这里使用HashSet作为演示Set接口的实现类对象
		 * 
		 * 所有使用的方法都是Collection接口中的方法！！！
		 */
		Set set = new HashSet();
		
		/*
		 * 无序，是添加顺序和保存顺序不一致，称之为 无序！！！
		 */
		set.add(5);
		set.add(6);
		set.add(3);
		set.add(1);
		set.add(4);
		set.add(2);
		
		/*
		 * Set集合中不能出现相同元素！！！
		 */
		System.out.println(set.add(5));
		
		System.out.println(set);
	}
}
//经典案例
import java.util.HashSet;
class Person {
	private int id;
	private String name;
	private int age;
	
	public Person() {}

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

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	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 "Person [id=" + id + ", name=" + name + ", age=" + age + "]";
	}
	
	@Override
	public boolean equals(Object obj) {
		System.out.println("Person类的equals方法");
		return super.equals(obj);
	}
	
	@Override
	public int hashCode() {
		System.out.println("Person类的hashCode方法");
		return 1;
	}
}

public class Demo2 {
	public static void main(String[] args) {
		Person p1 = new Person(1, "于甜甜", 20);
		Person p2 = new Person(2, "预期", 19);
		Person p3 = new Person(3, "郁儿", 16);
		Person p4 = new Person(4, "振芳", 15);
		Person p5 = new Person(5, "鼎儿", 14);
		Person p6 = new Person(6, "记儿", 14);
		Person p7 = new Person(1, "凡儿", 20);
		
		HashSet set = new HashSet();
		
		set.add(p1);
		System.out.println("这一句无关紧要的话");
		set.add(p2);
		set.add(p3);
		set.add(p4);
		set.add(p5);
		set.add(p6);
		set.add(p7);
		System.out.println(set)；
	}
}

TreeSet()

import java.util.Comparator;
import java.util.TreeSet;

/*
树形结构的特征：
	1. 存在根节点
	2. 添加元素需要比较，必须有比较元素的方式和方法
	
添加到TreeSet集合中的元素有两种方案：
	1. 存在自然顺序，数字 10 20
	2. 实现一些方法！！！
		方案1: Comparable接口	
			实现的方法 int compareTo(Object o);
		方案2：Comparator接口
			实现的方法 int compare(Object o1, Object o2);
 */

class PC implements Comparable {
	String name;
	int price;
	
	public PC() {}

	public PC(String name, int price) {
		super();
		this.name = name;
		this.price = price;
	}

	@Override
	public int compareTo(Object o) {
		PC p = (PC) o;
		System.out.println(this.name + " 和  " + p.name);
		return this.price - p.price;
	}

	@Override
	public String toString() {
		return "PC [name=" + name + ", price=" + price + "]";
	}
}

/*
 * 定义一个类，遵从Comparator接口，实现compare方法，完成一个自定义比较器
 */
class MyCompare implements Comparator {

	@Override
	public int compare(Object o1, Object o2) {
		PC p1 = (PC) o1;
		PC p2 = (PC) o2;
		System.out.println("使用了自定义比较器方法！！！");
		return p1.price - p2.price;
	}
	
}

public class Demo3 {
	public static void main(String[] args) {
		/*
		 * 使用自定义比较器，作为TreeSet构造方法的参数，用于提供给TreeSet
		 * 比较其中保存的数据类型。
		 */
		TreeSet set = new TreeSet(new MyCompare());
		
		set.add(new PC("外星人", 21998));
		set.add(new PC("MacBook Pro", 18030));
		set.add(new PC("ThinkPad X1", 11998));
		set.add(new PC("ThinkPad T400", 15880));
		set.add(new PC("小米笔记本 Pro", 7999));
		
		System.out.println(set);
	}
}