概述
集合特点:
1、用于存储对象的容器
2、集合的长度是可变的
3、集合中不可以存储基本数据类型
集合容器因为内部的数据结构不同,有多种具体容器,不断给的向上抽取,就形成了集合框架。
注意:
数组虽然也可以存储对象,但长度是固定的,集合长度是可变的。
集合框架的构成及分类
1、用于存储对象的容器
2、集合的长度是可变的
3、集合中不可以存储基本数据类型
集合容器因为内部的数据结构不同,有多种具体容器,不断给的向上抽取,就形成了集合框架。
注意:
数组虽然也可以存储对象,但长度是固定的,集合长度是可变的。
集合框架的构成及分类
Collection接口
整个集合体系的顶层Collection接口Collection的常见方法:
1、添加
add(e); (add方法的参数类型是Object。以便于接收任意类型对象。)
addAll(collection);
2、删除
remove(e);
removeAll(collection);
clear();
3、判断。
contains(e);
isEmpty();
4、获取
iterator(); 迭代器,集合的取出元素的方式,会直接访问集合中的元素。所以将迭代器通过内部类的形式来进行描述。通过容器的iterator()方法获取该内部类的对象。
size();
5、获取交集。
retainAll();
6、集合变数组。
toArray();
import java.util.*;
class CollectionDemo {
public static void main(String[] args) {
// method_add();
method_ret();
method_ite();
}
public static void method_ite() {
ArrayList al = new ArrayList();
al.add("Java 01");
al.add("Java 02");
al.add("Java 03");
al.add("Java 04");
//使用迭代器获取集合中元素
Iterator it = al.iterator();
while(it.hasNext()) {
sop(it.next());
}
/*
迭代器可以用for循环来表示
for(Iterator it = al.iterator() ; it.hasNext(); ) {
sop(it.next());
} */
}
public static void method_ret() {
ArrayList al1 = new ArrayList();
al1.add("Java 01");
al1.add("Java 02");
al1.add("Java 03");
al1.add("Java 04");
ArrayList al2 = new ArrayList();
al2.add("Java 01");
al2.add("Java 02");
al2.add("Java 05");
al2.add("Java 06");
//al1.retainAll(al2); //取交集,al1中只会保留和al2中相同的元素
al1.addAll(al2);
sop(al1);
sop(al2);
}
public static void method_add() {
ArrayList al = new ArrayList();
// 添加元素
al.add("Java 01");
al.add("Java 02");
al.add("Java 03");
al.add("Java 04");
sop(al);
al.remove("Java 04"); //删除元素,(al.clear())清空集合
sop(al);
sop(al.contains("Java 04")); //判断元素是否存在
sop(al.size());
}
public static void sop(Object obj) {
System.out.println(obj);
}
}
List
Collection|--List:元素是有序的,元素可以重复。因为该集合体系有索引。
|--ArrayList:底层的数据结构使用的是数组结构。特点:查询速度很快。但是增删稍慢。线程不同步。
|--LinkedList:底层使用的链表数据结构。特点:增删速度很快,查询稍慢。线程不同步。
|--Vector:底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。
List:特有方法,凡是可以操作角标的方法都是该体系特有的方法。
1、添加
add(index,element);
addAll(index,Collection);
addAll(index,Collection);
2、删除
remove(index);
3、修改
set(index,element);
4、获取
get(index):
subList(from,to);
listIterator();
int indexOf(obj):获取指定元素的位置。
ListIterator listIterator();
subList(from,to);
listIterator();
int indexOf(obj):获取指定元素的位置。
ListIterator listIterator();
import java.util.*;
class Demo1List {
public static void sop(Object obj) {
System.out.println(obj);
}
public static void main(String[] args) {
method_1();
sop("--------------------------------");
method_2();
}
public static void method_1() {
ArrayList al = new ArrayList();
al.add("Java 01");
al.add("Java 02");
al.add("Java 03");
al.add(3,"Java 04"); //在指定位置添加元素。
sop(al);
al.remove(3); 删除指定位置的元素。
sop(al);
al.set(2, "Java 01"); //修改元素。
sop(al);
sop(al.get(0)); //通过角标获取元素。
sop(al.indexOf("Java 01"));
sop(al.subList(0,2)); //获取子集
//list特有取出元素的方式
for(int x = 0; x < al.size() ; x++) {
sop(al.get(x));
}
}
public static void method_2() {
ArrayList al = new ArrayList();
al.add("Java 01");
al.add("Java 02");
al.add("Java 03");
ListIterator it = al.listIterator();
while(it.hasNext()) {
Object obj = it.next();
if(obj.equals("Java 02"))
it.remove(); //将java02的引用从集合中删除了。
sop(obj);
}
it.add("Java 04");
sop(it.hasNext());
sop(it.hasPrevious());
//反向获取集合里的元素
while(it.hasPrevious()) {
sop(it.previous());
}
sop(al);
}
}
注意:
ist集合特有的迭代器。ListIterator是Iterator的子接口。
在迭代时,不可以通过集合对象的方法操作集合中的元素。因为会发生ConcurrentModificationException异常。所以,在迭代器时,只能用迭代器的放过操作元素,可Iterator方法是有限的,只能对元素进行判断,取出,删除的操作,如果想要其他的操作如添加,修改等,就需要使用其子接口,ListIterator。该接口只能通过List集合的listIterator方法获取。
在迭代时,不可以通过集合对象的方法操作集合中的元素。因为会发生ConcurrentModificationException异常。所以,在迭代器时,只能用迭代器的放过操作元素,可Iterator方法是有限的,只能对元素进行判断,取出,删除的操作,如果想要其他的操作如添加,修改等,就需要使用其子接口,ListIterator。该接口只能通过List集合的listIterator方法获取。
Vector、ArrayList、LinkedList
|--List:
|--ArrayList:底层的数据结构使用的是数组结构。特点:查询速度很快。但是增删稍慢。线程不同步。
|--LinkedList:底层使用的链表数据结构。特点:增删速度很快,查询稍慢。线程不同步。
|--Vector:底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。
|--ArrayList:底层的数据结构使用的是数组结构。特点:查询速度很快。但是增删稍慢。线程不同步。
|--LinkedList:底层使用的链表数据结构。特点:增删速度很快,查询稍慢。线程不同步。
|--Vector:底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。
Vector
Vector特有的取出方式:枚举
枚举和迭代器很像,其实枚举和迭代是一样的。因为枚举的名称以及方法的名称都过长,所以被迭代器取代了。
import java.util.*;
class Demo2Vector {
public static void main(String[] args) {
Vector v = new Vector();
v.add("Java 01");
v.add("Java 02");
v.add("Java 03");
v.add("Java 04");
//类似于迭代器
Enumeration e = v.elements();
while(e.hasMoreElements())
System.out.println(e.nextElement());
}
}
LinkedList
LinkedList:特有方法:
addFirst();
addLast();
addFirst();
addLast();
getFirst();
getLast();
获取元素,但不删除元素。如果集合中没有元素,会出现NoSuchElementException
removeFirst();
removeLast();
获取元素,但是元素被删除。如果集合中没有元素,会出现NoSuchElementException
在JDK1.6出现了替代方法。
offerFirst();
offerLast();
peekFirst();
peekLast();
获取元素,但不删除元素。如果集合中没有元素,会返回null。
pollFirst();
pollLast();
获取元素,但是元素被删除。如果集合中没有元素,会返回null。
import java.util.*;
class Demo3LinkedList {
public static void main(String[] args) {
LinkedList link = new LinkedList();
//添加元素至最前面
link.addFirst("Java 01"); //offerFirst()
link.addFirst("Java 02");
link.addFirst("Java 03");
link.addFirst("Java 04");
link.add(0, "Java 00");
sop(link);
sop(link.getFirst()); //peekFirst() //获取第一个元素,但不删除
sop(link.removeFirst()); //pollFirst() //获取第一元素,会删除
sop(link.size());
//LinkedList特有的获取元素的操作
while(!link.isEmpty())
sop(link.removeFirst());
}
public static void sop(Object obj) {
System.out.println(obj);
}
}
在JDK1.6出现了替代方法。
offerFirst();
offerLast();
peekFirst();
peekLast();
获取元素,但不删除元素。如果集合中没有元素,会返回null。
pollFirst();
pollLast();
获取元素,但是元素被删除。如果集合中没有元素,会返回null。
offerFirst();
offerLast();
peekFirst();
peekLast();
获取元素,但不删除元素。如果集合中没有元素,会返回null。
pollFirst();
pollLast();
获取元素,但是元素被删除。如果集合中没有元素,会返回null。
使用LinkedList模拟一个堆栈或者队列数据结构(堆栈:先进后出 如同一个杯子,队列:先进先出 First in First out FIFO 如同一个水管。)
import java.util.*;
//把方法定义到一个类里面,以便不同的调用者,都能够调用
class Queue {
private LinkedList link;
Queue() {
link = new LinkedList();
}
public void myAdd(Object obj) { //定义一个方法,添加元素至末尾
link.offerLast(obj);
}
public Object myGet() { //定义一个方法,获取最前面的元素
return link.pollFirst();
}
public boolean myIf() { //定义一个方法,判断集合是否为空
return link.isEmpty();
}
}
class Test1LinkedList {
public static void main(String[] args) {
Queue ueue = new Queue();
ueue.myAdd("Java 01");
ueue.myAdd("Java 02");
ueue.myAdd("Java 03");
ueue.myAdd("Java 04");
while(!ueue.myIf()) {
System.out.println(ueue.myGet());
}
}
}
ArrayList
去除ArrayList集合中的重复元素:
import java.util.*;
class Test2ArrayList {
public static void main(String[] args) {
ArrayList al = new ArrayList();
al.add("Java 01");
al.add("Java 02");
al.add("Java 03");
al.add("Java 01");
al.add("Java 03");
al.add("Java 04");
al = singleElement(al); //调用去除重复数组的方法
System.out.println(al);
}
public static ArrayList singleElement(ArrayList al) {
ArrayList newal = new ArrayList(); //定义一个临时容器,用来存储不不重复的元素
//遍历数组
Iterator it = al.iterator();
while(it.hasNext()) {
Object obj = it.next();
if(!newal.contains(obj)) { //判断临时数组里面有没有与原数组相同的元素
newal.add(obj);
}
}
return newal;
}
}
将自定义对象作为元素存到ArrayList集合中,并去除重复元素
思路:
1、对人描述,将数据封装进人对象。
2、定义容器,将人存入。
3、取出。
1、对人描述,将数据封装进人对象。
2、定义容器,将人存入。
3、取出。
import java.util.*;
class Test3ArrayList {
public static void main(String[] args) {
ArrayList<Person> arr = new ArrayList<Person>();
arr.add(new Person("Jack",20));
arr.add(new Person("Luck",30));
arr.add(new Person("Moli",20));
arr.add(new Person("Paul",25));
arr.add(new Person("Luck",30));
arr = singleElement(arr);
Iterator<Person> it = arr.iterator();
//获取集合里面每一个对象
while(it.hasNext()) {
Person p = it.next();
System.out.println(p.getName()+","+p.getAge());
}
}
public static ArrayList<Person> singleElement(ArrayList<Person> arr) {
ArrayList<Person> newArr = new ArrayList<Person>();
Iterator<Person> it = arr.iterator();
while(it.hasNext()) {
Person p = it.next(); //使用了泛型,因此不用向下转型
if(!newArr.contains(p)) { //contains底层用的是equals,所以要复写equals方法
newArr.add(p);
}
}
return newArr;
}
}
class Person {
private String name;
private int age;
Person(String name,int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public boolean equals(Object obj) {
if(!(obj instanceof Person)) //判断对象的类型
throw new RuntimeException();
Person p = (Person)obj; //向下转型
return this.name.equals(p.name)&&this.age == p.age; //这里的equals方法调用的是字符串的
}
}
HashSet、TreeSet
HashSet
Set:无序,不可以重复元素。
|--HashSet:数据结构是哈希表。线程是非同步的。
保证元素唯一性的原理:判断元素的hashCode值是否相同。
如果相同,还会继续判断元素的equals方法,是否为true。
|--HashSet:数据结构是哈希表。线程是非同步的。
保证元素唯一性的原理:判断元素的hashCode值是否相同。
如果相同,还会继续判断元素的equals方法,是否为true。
import java.util.*;
class Demo1HashSet {
public static void main(String[] args) {
HashSet hs = new HashSet();
System.out.println(hs.add("Java 01")); //添加成功返回true
System.out.println(hs.add("Java 01")); //有相同元素,添加失败,返回false
hs.add("Java 02");
hs.add("Java 03");
hs.add("Java 03");
hs.add("Java 04");
Iterator it = hs.iterator();
while(it.hasNext())
System.out.println(it.next());
}
}
往HashSet集合中存入自定义对象,姓名和年龄相同为同一个人,重复元素
思路:
1、定义一个类,用来描述人,并且类里面重写equals,hashCode方法
2、定义一个集合,将人存入
2、取出
import java.util.*;
class Demo2HashSet {
public static void main(String[] args) {
HashSet<Persons> hs = new HashSet<Persons>();
//添加元素
hs.add(new Persons("Jack",20));
hs.add(new Persons("Luck",30));
hs.add(new Persons("Moli",20));
hs.add(new Persons("Paul",25));
hs.add(new Persons("Luck",30));
//获取对象
Iterator<Persons> it = hs.iterator();
while(it.hasNext()) {
Persons p = it.next();
System.out.println(p.getName()+","+p.getAge());
}
}
}
class Persons {
private String name;
private int age;
Persons(String name,int age) {
this.name =name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public int hashCode() {
return name.hashCode(); //字符串中有hashCode()方法
}
//重写equals方法
public boolean equals(Object obj) {
if(!(obj instanceof Persons))
throw new RuntimeException();
Persons p = (Persons)obj;
return this.name.equals(p.name)&&this.age == p.age; //调用的字符串 equals方法
}
}
TreeSet
|--TreeSet:可以对Set集合中的元素进行排序。底层数据结构是二叉树。
保证元素唯一性的依据:
compareTo方法return 0.
TreeSet排序的第一种方式:
让元素自身具备比较性。元素需要实现Comparable接口,覆盖compareTo方法。也种方式也成为元素的自然顺序,或者叫做默认顺序。
往TreeSet集合中存储自定义对象学生,按照学生的年龄进行排序。
import java.util.*;
class Demo3TreeSet {
public static void main(String[] args) {
TreeSet<Student> ts = new TreeSet<Student> ();
ts.add(new Student("Jack",20));
ts.add(new Student("Luck",30));
ts.add(new Student("Moli",20));
ts.add(new Student("Paul",25));
ts.add(new Student("Luck",30));
Iterator<Student> it = ts.iterator();
while(it.hasNext())
{
Student stu = it.next();
System.out.println(stu.getName()+"..."+stu.getAge());
}
}
}
class Student implements Comparable<Object> { //实现该接口,强制让学生具有比较性
private String name;
private int age;
Student(String name,int age) {
this.name =name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
//重写compareTo方法
public int compareTo(Object obj) {
if(!(obj instanceof Student)) //判断类型
throw new RuntimeException();
Student s = (Student)obj;
if(this.age > s.age)
return 1;
//当年龄相同时,再判断名字即可,字符串已经具有compareTo()方法
if(this.age == s.age)
return this.name.compareTo(s.name);
return -1;
}
}
TreeSet的第二种排序方式。
当元素自身不具备比较性时,或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。在集合初始化时,就有了比较方式。
往TreeSet集合中存储自定义对象学生,按照学生的姓名进行排序。
import java.util.*;
class Demo4TreeSet {
public static void main(String[] args) {
TreeSet<Student> ts = new TreeSet<Student> ();
ts.add(new Student("Jack",20));
ts.add(new Student("Luck",30));
ts.add(new Student("Moli",20));
ts.add(new Student("Paul",25));
ts.add(new Student("Luck",30));
Iterator<Student> it = ts.iterator();
while(it.hasNext())
{
Student stu = it.next();
System.out.println(stu.getName()+"..."+stu.getAge());
}
}
}
class ComparatorByName implements Comparator<Object> {
public int compare(Object o1,Object o2) { //比较器要传入两个 对象进来比较
Student s1 = (Student)o1;
Student s2 = (Student)o2;
int num = s1.getName().compareTo(s2.getName()); //比较两者的名字,如果相同则返回0
if(num == 0)
return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge())); //基本数据类型中也已经具备了compareTo()方法
return num;
}
}
二叉树示意图: