目录
2.LinkedHashSet 有序 使用场合：元素唯一+需要排序
紧贴API来进行学习
一.Collection
1.概述
所有这个分支下面的实现都具有该接口中的方法。在某些场合，使用Collection具有更普遍的适应性。
Collection是一个接口，不可以直接new，只能new它的实现类。
Collection coll = new ?();
所有已知子接口
2.方法介绍
add() - 添加一个元素
addAll() - 添加一组元素
clear() - 清空整个集合
contains() -判断 是否包含某个元素
containsAll() - 判断 是否包含一组元素
equals() - 比较一个集合与另一个集合是否相同，挨个比较集合中所有元素
hashCode() - 返回此集合的哈希码
isEmpty() - 是不是size为0，元素的个数是不是为0
iterator() - 获得此集合的迭代器，用来遍历集合
remove() - 删除指定的元素
removeAll() - 删除一组指定的元素
retainAll() - 当前集合与指定集合(参数)求交集
size() - 返回元素个数
toArray() - 将集合转为数组
3.子接口-List
1.概述
有序的可重复的 collection（也称为序列）。内部维护一个索引(下标)。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素有序，就是插入顺序（位置）
2.示意图
3.List的操作
除了具有Collection的所有方法外，还提供通过下标来操作的方法
add(int index, E element) - 将某个元素添加到指定的下标处
addAll(int index, Collection<? extends E> c) - 将一组元素添加到指定的下标处
get(int index) - 通过下标来获得某个具体的元素
indexOf(Object o) -获得指定元素的下标，从集合的头开始找
lastIndexOf(Object o) - 获得指定元素的下标，集合的尾部开始找
listIterator() - 返回List的特有的迭代器(ListIterator)，ListIterator功能比较强大
remove(int index) -通过下标来删除元素
set(int index, E element) - 替换指定下标位置的元素
subList(int fromIndex, int toIndex) - 通过下标截取子集
1.add addAll
// add
Collection<String> news = new ArrayList<String>();
news.add("新闻000");
news.add("新闻111");
news.add("新闻222");
news.add("新闻333");
System.out.println(news);
// add all
ArrayList<String> news2 = new ArrayList<String>();
news2.add("新闻444");
news2.add("新闻555");
System.out.println(news2);
news.addAll(news2);// 在news中add入news2
System.out.println(news);
news2.addAll(news);// 在news2中add入news
System.out.println(news2);
news.addAll(news);//在news中add入news
System.out.println(news);
add addAll内存分析
2.constains constainsAll
// constains
boolean r = news.contains("新闻111");
System.out.println(r);
// constainsall
r = news.containsAll(news2);
System.out.println(r);
3.Iterator
迭代器迭代 it.next()只能输出一次，要循环输出，判断条件是是否有下一个 while (it.hasNext())
Iterator<String> it = news.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
4.toArray
System.out.println("=====================老虎============================");
// toArray 返回包含此 collection 中所有元素的数组 即使 collection 受到数组的支持，此方法也必须分配一个新的数组
Collection<Tigger> longZi = new ArrayList<Tigger>();
longZi.add(new Tigger("大老虎1", "公"));
longZi.add(new Tigger("大老虎2", "母"));
longZi.add(new Tigger("大老虎3", "公"));
System.out.println(longZi);
Object[] lzArray = longZi.toArray();
for (Object object : lzArray) {
// 强转
Tigger t = (Tigger) object;
System.out.println(t.getName() + t.getSex());
}
System.out.println("=======================");
// toArray 返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。
// String[] y=x.toString(new String[0]);
Tigger[] tiggers = longZi.toArray(new Tigger[0]);
for (Tigger tigger : tiggers) {
// 不用强转
System.out.println(tigger.getName() + tigger.getSex());
}
5.listIterato
倒序输出 正序输出
System.out.println("=========================listIterato==============================");
// listIterato
List<Tigger> longZi2 = new ArrayList<Tigger>();
longZi2.add(new Tigger("大老虎1", "公"));
longZi2.add(new Tigger("大老虎2", "母"));
longZi2.add(new Tigger("大老虎3", "公"));
longZi2.add(new Tigger("大老虎4", "公"));
longZi2.add(new Tigger("大老虎5", "公"));
longZi2.add(new Tigger("大老虎6", "公"));
ListIterator<Tigger> lit = longZi2.listIterator();
while (lit.hasNext()) {
Tigger t = lit.next();
System.out.println(t.getName() + t.getSex());
}
System.out.println("====逆序====");
// 要先正序输出然后才可以逆序输出 因为正序输出后指针停在了最后一位，就可以逆序输出
while (lit.hasPrevious()) {
Tigger t = lit.previous();
System.out.println(t.getName() + t.getSex());
}
6.removeRange
如何使用被保护的方法？创建一个子类来重写
步骤：1.创建一个子类，继承ArrayList，然后重写removeRange
2.在测试类创建子类对象，直接调用方法
package com.gongsi.cn.oa.work809.test1;
import java.util.ArrayList;
//为了使用这个被保护的方法removeRange 重写
public class MyArrayList<E> extends ArrayList<E>{
@Override
protected void removeRange(int fromIndex, int toIndex) {
// TODO Auto-generated method stub
super.removeRange(fromIndex, toIndex);
}
}
MyArrayList<String> names2 = new MyArrayList<String>();
for (int i = 0; i < 21; i++) {
names2.add("啊" + i);
}
System.out.println(names2);
names2.removeRange(6, 10);
System.out.println(names2);
}
7.remove removeAll
package com.gongsi.cn.oa.work809.test1;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
public class TestTigger2 {
public static void main(String[] args) {
List<Tigger> longZi = new ArrayList<Tigger>();
longZi.add(new Tigger("大老虎1", "公"));
longZi.add(new Tigger("大老虎2", "母"));
longZi.add(new Tigger("大老虎3", "公"));
Tigger t1=new Tigger("大老虎4", "公");
longZi.add(t1);
Tigger t2=new Tigger("大老虎5", "公");
longZi.add(t2);
System.out.println("大笼子"+longZi);
List<Tigger> longZi2 = new ArrayList<Tigger>();
longZi2.add(t1);
longZi2.add(t2);
System.out.println("小笼子"+longZi2);
boolean isYes=longZi.removeAll(longZi2);//把longZi1中，与longZi2相同的部分全部移除
System.out.println("longZi1中，与longZi2相同的部分是否移除成功？"+isYes);
System.out.println(longZi);
// boolean r=longZi.retainAll(longZi2);
// System.out.println(r);
}
}
注意注意！！！如果是这种情况则不能remove！！
package com.gongsi.cn.oa.work809.test1;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
public class TestTigger2 {
public static void main(String[] args) {
List<Tigger> longZi = new ArrayList<Tigger>();
longZi.add(new Tigger("大老虎1", "公"));
longZi.add(new Tigger("大老虎2", "母"));
longZi.add(new Tigger("大老虎3", "公"));
longZi.add(new Tigger("大老虎4", "公"));
longZi.add(new Tigger("大老虎5", "公"));
// Tigger t1=new Tigger("大老虎4", "公");
// longZi.add(t1);
// Tigger t2=new Tigger("大老虎5", "公");
// longZi.add(t2);
System.out.println("大笼子"+longZi);
List<Tigger> longZi2 = new ArrayList<Tigger>();
// longZi2.add(t1);
// longZi2.add(t2);
longZi2.add(new Tigger("大老虎4", "公"));
longZi2.add(new Tigger("大老虎5", "公"));
System.out.println("小笼子"+longZi2);
boolean isYes=longZi.removeAll(longZi2);//把longZi1中，与longZi2相同的部分全部移除
System.out.println("longZi1中，与longZi2相同的部分是否移除成功？"+isYes);
System.out.println(longZi);
// boolean r=longZi.retainAll(longZi2);
// System.out.println(r);
}
}
因为老虎4，老虎5其实他们不是相同的对象，不是同一个老虎
4.队列Queue
在处理元素前用于保存元素的 collection。除了基本的 Collection 操作外，队列还提供其他的插入、提取和检查操作。每个方法都存在两种形式：一种抛出异常（操作失败时），另一种返回一个特殊值（null 或 false，具体取决于操作）。插入操作的后一种形式是用于专门为有容量限制的 Queue 实现设计的；在大多数实现中，插入操作不会失败。
用一个有容量限制的Queue来演示插入，抛出异常和返回特殊值。更建议使用抛出异常的，只有抛出了才知道要怎么处理
package com.gongsi.cn.oa.work809.test1;
import java.util.concurrent.ArrayBlockingQueue;
public class TestQuece {
public static void main(String[] args) {
ArrayBlockingQueue<String>names=new ArrayBlockingQueue<String>(4);
names.add("肖肖");
names.add("小博");
names.add("柯柯");
names.add("刘老师");
names.add("Lisa");
System.out.println(names);
}
}
用offer直接不输出，不利于排错
5.栈
package com.gongsi.cn.oa.work809.test1;
import java.util.Stack;
public class TestStack {
public static void main(String[] args) {
Stack<String> names=new Stack<String>();
//进栈 先进后出
names.push("一号大明星");
names.push("二号大明星");
names.push("八十五大明星");
names.push("一白零五号大明星");
names.push("九十五号大明星");
System.out.println("出栈前："+names);
//一个个出栈
// String n=names.pop();
// System.out.println("出栈后："+names);
// n=names.pop();
// System.out.println("出栈后："+names);
//循环出栈
while (!(names.isEmpty())) {
String n=names.pop();
System.out.println("出栈后："+names);
}
}
}
6.子接口Set
1.HashSet 无序
package com.gongsi.cn.oa.work809.test2;
//重写Hash方法和equals
public class Student{
private String name;
private int 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;
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Student() {
super();
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
//无序
Set<Student> stus=new HashSet<Student>();
stus.add(new Student("依依",1));
stus.add(new Student("尔尔",2));
stus.add(new Student("伞伞",3));
stus.add(new Student("斯斯",4));
stus.add(new Student("呜呜",5));
stus.add(new Student("六六",6));
stus.add(new Student("琪琪",7));
//在set集合我们主观上认为（重写equals方法），名字和年龄一样表示同一个人，只显示一个人
//不重写就是客观 认为他们不是同一个人，两个人都显示
stus.add(new Student("琪琪",7));
//System.out.println(stus);
for (Student student : stus) {
System.out.println(student);
}
2.LinkedHashSet 有序 使用场合：元素唯一+需要排序
//有序 LinkedHashSet使用场合：元素唯一+需要排序
LinkedHashSet<Student> stus1=new LinkedHashSet<Student>();
stus1.add(new Student("依依",1));
stus1.add(new Student("尔尔",2));
stus1.add(new Student("伞伞",3));
stus1.add(new Student("斯斯",4));
stus1.add(new Student("呜呜",5));
stus1.add(new Student("六六",6));
stus1.add(new Student("琪琪",7));
//在set集合我们主观上认为（重写equals方法），名字和年龄一样表示同一个人，只显示一个人
//不重写就是客观 认为他们不是同一个人，两个人都显示
stus1.add(new Student("琪琪",7));
//System.out.println(stus1);
for (Student student : stus1) {
System.out.println(student);
}
3.TreeSet
它会按照自然顺序或比较器提供的顺序进行排序。
如果要使用TreeSet，则添加到里面的元素必须实现Comparable接口
或者提供定制的Comparator接口的实现，提供这了Comparator接口的实现后可以不用再实现Comparable接口！！！
package com.gongsi.cn.oa.work809.test1;
import java.util.TreeSet;
public class TestTreeSet {
public static void main(String[] args) {
TreeSet<String> names =new TreeSet<String>();
names.add("b");
names.add("j");
names.add("y");
names.add("x");
names.add("s");
names.add("z");
names.add("d");
names.add("a");
System.out.println(names);
TreeSet<Integer> number =new TreeSet<Integer>();
number.add(1);
number.add(6);
number.add(9);
System.out.println(number);
}
} 
678
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
