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());
}
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
