Java中集合的方法及子集（上）

package javaStudy;

import java.util.ArrayList;//导入集合中的ArrayList类包

/**
 * 
 * @author zhaocx1
 * 
 */
/*
 * Collection[List(ArrayList)(LinkedList)(Vector)] Set[(Hashset)(TreeSet)]
 * 为什么会出现这么多的容器呢？ 因为 每一个容器对数据的存储方式都不同。 这个存储方式称之为：数据结构。
 * 
 * 1.add方法的参数类型是Object。以便于接受任意类型对象。 2.集合中存储的都是对象的引用（地址）
 */
/*
 * Collection
 *     1--List:元素是有序的，元素可以重复。因为该集合体系有索引。
 *     1--set:元素是无序的，元素不可以重复。
 * List:
 *     特有方法：凡是可以操作角标的方法都是该体系特有的方法。
 * 增
 *   add(index,element);
 *   addAll(index,Collection);
 * 删
 *   remove(index);
 * 改
 *   set(index,element);
 * 查
 *   get(index):
 *   subList(from,to);
 *   ListIterator();
 */
public class CollectionDemo1 {
	public static void main(String[] args) {//主函数，整个函数的切入点
		
		// 创建一个集合容器。使用Collection接口的子类。ArrayList
		ArrayList al = new ArrayList();

		// 1.添加元素。
		al.add("java01"); // add(Object obj);
		al.add("java02");
		al.add("java03");
		al.add("java04");

		// 打印集合。
		sop("原集合" + al);

		// 2.获取个数，集合长度。
		sop("size:" + al.size());

		// 3.删除元素。
		// al.remove("java02");

		// sop(al);
		// al.clear();//清空集合。

		// 4.判断集合。
		sop("java03是否存在：" + al.contains("java03"));
		sop("集合是否为空？" + al.isEmpty());
	}

	public static void sop(Object obj) { // 将一个静态的打印方法封装到sop中，其它对象可以调用该方法，sop是封装的意思
		System.out.println(obj);
	}
}

package javaStudy;
/**
 * 
 * @author zhaocx1
 * 
 */
import java.util.ArrayList;//导入集合中ArrayList类包
/*
 *什么是迭代器呢？
 *其实就是集合的取出元素的方式。
 *
 *就把取出方式定义在集合的内部，
 *这样取出方式就可以直接访问集合内容的元素。 
 *那么取出方式就被定义成了内部类。
 *而每个容器的数据结构不同，
 *所以取出的动作细节也不一样。但是都有共性内容判断和取出。那么可以将写共性抽取。
 *那么这些内部类都符合一个规则，该规则是Iterator.
 *如何获取集合的取出对象呢？
 *通过一个对外提供的方法，iterator():
 * 
 */
public class CollectionDemo2 {
	public static void main(String[] args) {
		method_2();
	}

	public static void method_2() {
		// 创建一个集合容器。使用Collection接口的子类。ArrayList
		ArrayList al1 = new ArrayList();

		al1.add("java01");//添加元素
		al1.add("java02");
		al1.add("java03");
		al1.add("java04");

		ArrayList al2 = new ArrayList();
		
		al2.add("java01");
		al2.add("java02");
		al2.add("java05");
		al2.add("java06");
		
		al1.removeAll(al2);//取出al1中和al2相同的元素
		
		al1.retainAll(al2);// 取交集。al1中只会保留和al2中相同的元素。
		
		sop("all:" + al1);//打印集合的元素
		sop("al2:" + al2);

	}

	public static void sop(Object obj) {// 将一个静态的打印方法封装到sop中，其它对象可以调用该方法
		System.out.println(obj);
	}
}

package javaStudy;

import java.util.ArrayList;//导入集合中的ArrayList类包
import java.util.Iterator;///导入集合中的Iterator类包

/**
 * 
 * @author zhaocx1
 * 
 */
public class CollectionDemo3 {
	public static void main(String[] args) {// 主函数，整个函数的切入点
		method_get();// 调用静态方法
	}

	public static void method_get() {// 定义一个静态方法
		ArrayList al = new ArrayList();// 创建一个集合容器

		al.add("java01");// 添加元素
		al.add("java02");
		al.add("java03");
		al.add("java04");

		Iterator it = al.iterator(); // 获取迭代器，用于取出集合中的元素。
		/*
		 * while(it.hasNext()) { sop(it.next()); }//获取迭代器的第一种方法
		 */
		for (Iterator it1 = al.iterator(); it1.hasNext();) {// 获取迭代器的第二种方法
			sop(it1.next());
		}
	}

	public static void sop(Object obj) {// 将一个静态的打印方法封装到sop中，其它对象可以调用该方法
		System.out.println(obj);
	}
}

package javaStudy;
/**
 * 
 * @author zhaocx1
 *
 */
/*
 * Collection： List：
 *	1.ArrayList 底层的数据结构使用的是数组结构。特点： 查询速度很快，但是增删稍慢。线程不同步。
 *	2.LinkedList 底层使用的是链表数据结构。特点：增删速度很快，查询稍慢。线程同步
 *	3.Vorectr:底层是数组数据结构，线程同步。无论增删和查询都很慢，被ArrayList替代了。
 *
 */
public class CollectionZ {
	public static void main(String[] args) {//主函数，整个函数的切入点
		System.out.println("hello world");
	}

}

package javaStudy;

/**
 * 
 * @author zhaocx1
 * 
 */
/*
 *去除ArrayList集合中的重复元素。
 * 
 */
import java.util.ArrayList;//导入集合中的ArrayList类包
import java.util.Iterator;//导入集合中的Iterator类包

public class ArrayListTest {

	public static void main(String[] args) {// 主函数，整个函数的切入点
		ArrayList a1 = new ArrayList();// 定义一个集合容器用于存放集合中的元素
		a1.add("java01");// 添加元素，因为ArrayList集合中的元素是有顺序的，所以元素可以有重复
		a1.add("java02");
		a1.add("java01");
		a1.add("java02");
		a1.add("java01");
		a1.add("java03");
		sop("old ai=" + a1);// 打印操作前的集合
		a1 = singleElement(a1);// 调用静态方法保证元素的不可重复性
		sop("new al=" + a1);// 打印操作后的集合
	}

	public static ArrayList singleElement(ArrayList al) {// 定义一个静态方法，用于判断集合中元素的不可重复性
		// 定期一个临时容器。
		ArrayList newA1 = new ArrayList();// 定义一个临时的集合用于存储操作的集合元素
		Iterator it = al.iterator();// 定义一个迭代器，用于获取集合中的元素
		while (it.hasNext()) { // 在迭代时循环中next调用一次，就要hasnext判断一次。
			Object obj = it.next();// 用Object类接受取到的集合
			if (!newA1.contains(obj))// 判断元素是否重复
				newA1.add(obj);
		}
		return newA1;// 返回集合
	}

	public static void sop(Object obj) {// 将一个静态的打印方法封装到sop中，其它对象可以调用该方法
		System.out.println(obj);
	}
}

package javaStudy;

/**
 * 
 * @author zhaocx1
 * 集合练习
 */
import java.util.ArrayList;//导入集合中的ArrayList类包
import java.util.Iterator;//导入集合中的Iterator类包
/*
 * 将自定义对象作为元素存到ArrayList集合中，并去除重复元素。
 * 比如：存人对象，同姓名同年龄，视为同一个人，为重复元素。
 *
 * 思路：
 * 1.对人描述，将数据封装进入人对象。
 * 2.定义容器，将人存入。
 * 3.取出。
 *
 * List集合判断元素是否相同，依据的是元素的equals方法。
 */

class Person {// 定义一个Person类
	private String name;// 定义name属性
	private int age;// 定义age属性

	Person(String name, int age) {// 对Person进行构造函数，并将属性以参数形式传递进去
		this.name = name;
		this.age = age;

	}

	public boolean equals(Object obj) {// 定义一个方法判断Object类是否包含Person类，如果包含向下转型，从而Object类可以接收Person类
		if (!(obj instanceof Person))
			return false;
		Person p = (Person) obj;// 向下转型
		return this.name.equals(p.name) && this.age == p.age;// 返回本类中的name和age属性

	}

	public String getName() {// 定义一个获取name属性的方法
		return name;// 返回值为name
	}

	public int getAge() {// 定义一个获取age属性的方法
		return age;// 返回值为age
	}
}

public class ArrayListTest2 {

	public static void main(String[] args) {//主函数，整个函数的切入点
		ArrayList a1 = new ArrayList();//定义一个集合，用于存储集合中的元素
		a1.add(new Person("lisi01", 30));//添加元素
		a1.add(new Person("lisi02", 32));
		a1.add(new Person("lisi02", 32));
		a1.add(new Person("lisi03", 33));
		a1.add(new Person("lisi04", 35));
		a1.add(new Person("lisi04", 35));

		a1 = singleElement(a1);

		Iterator it = a1.iterator();
		while (it.hasNext()) {
			Person p = (Person) it.next();
			sop(p.getName() + "...." + p.getAge());
		}

	}

	public static ArrayList singleElement(ArrayList al) {//定义静态方法用于判断集合中元素的不可重复性
		// 定期一个临时容器。
		ArrayList newA1 = new ArrayList();
		Iterator it = al.iterator();//获取迭代器，对集合中的元素进行迭代
		while (it.hasNext()) { // 在迭代时循环中next调用一次，就要hasnext判断一次。
			Object obj = it.next();
			if (!newA1.contains(obj))//判断集合中的元素是否重复
				newA1.add(obj);
		}
		return newA1;//返回集合
	}

	public static void sop(Object obj) {// 将一个静态的打印方法封装到sop中，其它对象可以调用该方法
		System.out.println(obj);
	}
}

package javaStudy;

import java.util.LinkedList;//导入集合中的LinkedList类包

/**
 * 
 * @author zhaocx1 LinkList的相关内容
 */
/*
 * LinkedList:特有方法。 addFirst(); addLast();
 * 
 * getFirst(); getLast(); 获取元素 ，但不删除元素。
 * 
 * revomeFirst(); revomeLast(); 获取元素
 * ，但是元素被删除。如果集合中没有元素，会出现NoSuchElementException
 * 
 * 在JDK1.6出现了替代方法 。 offerFirst(); offerLast();
 * 
 * peekFirst(); peekLast(); 获取元素 ，但不删除元素。如果集合中没有元素，会返回null
 * 
 * pollFirst(); pollLast(); 获取元素 ，但是元素被删除。如果集合中没有元素，会返回null
 */

public class LinkedListDemo {
	public static void main(String[] args) {// 主函数，整个函数的切入点

		LinkedList link = new LinkedList();// 定义一个集合容器，用于存储集合中的元素
		link.addFirst("java01");// LinkList集合中的特有方法，addFirst,后添加的元素排在前面
		link.addFirst("java02");
		link.addFirst("java03");
		link.addFirst("java04");
		// sop(link);

		sop(link.getFirst());// 打印集合中的第一个元素
		sop(link.getLast());// 打印集合中的最后一个元素

		sop(link.removeFirst());// 删除集合中的第一个元素
		sop("size=" + link.size());// 打印集合的长度

		while (!link.isEmpty()) {// 判断集合是否为空
			sop(link.removeFirst());// 删除集合中的第一个元素
		}

	}

	public static void sop(Object obj) {// 将一个静态的打印方法封装到sop中，其它对象可以调用该方法
		System.out.println(obj);
	}
}

package javaStudy;

import java.util.LinkedList;//导入集合中的LinkedList包

/**
 * 
 * @author zhaocx1
 * 
 */
/*
 * 使用LinkedList模拟一个堆栈或者队列数据结构。
 * 堆栈：先进后出。如同一个杯子。
 * 队列：先进先出。First in First out FIFO 如同一个水管。
 * 
 *必须会
 */

class Queue {//定义一个类
	private LinkedList link;//私有化对象

	Queue() {//对Quene进行构造函数
		link = new LinkedList();//对对象进行初始化
	}

	public void myAdd(Object obj) {//定义一个集合中添加元素的方法，接受的参数为任意类型
		link.addFirst(obj);//往集合中添加元素，后添加的元素在前面
	}

	public Object myGet() {//定义一个获取元素的方法
		return link.removeLast();
	}

	public boolean isNull() {//定义一个判断元素是否为空的方法
		return link.isEmpty();
	}
}

public class LinkedListDemo2 {
	public static void main(String[] args) {//主函数，整个函数的切入点
		Queue d1 = new Queue();//new一个对象，对对象进行实例化
		d1.myAdd("java01");//往集合里添加元素
		d1.myAdd("java02");
		d1.myAdd("java03");
		d1.myAdd("java04");

		while (!d1.isNull()) {//判断集合是否为空，不为空输出打印集合中的元素
			System.out.println(d1.myGet());
		}

	}

}