---------------------- 黑马程序员 Android培训、期待与您交流！ ----------------------
集合概述
为什么出现集合类？
• 面向对象语言对事物的体现都是以对象的形式，所以为了方便对多 个对象的操作，就对对象进行存储，集合就是存储对象最常用的一 种方式。
数组和集合类同是容器，有何不同？
• 数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。 数组中可以存储基本数据类型，集合只能存储对象。
集合类的特点
• 集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。
Collection接口有两个子接口：
List（列表），Set（集）
List：可存放重复元素，元素存取是有序的。
Set：不可以存放重复元素，元素存取是无序的。
List接口中常用类
Vector：线程安全，但速度慢，已被ArrayList替代。
ArrayList：线程不安全，查询速度快。
LinkedList：链表结构，增删速度快。
取出LIst集合中元素的方式：
• get(int index)：通过脚标获取元素。
• iterator()：通过迭代方法获取迭代器对象。
import java.util.*;
public class _02_集合框架_共性方法 {
public static void main(String[]args)
{
//JiBen_Method();
Method_2();
}
public static void JiBen_Method()
{
//创建一个集合容器，使用Collection接口的子类， ArrayList
ArrayList al = new ArrayList();
//1，添加集合元素
al.add("Array_01");
al.add("Array_02");
al.add("Array_03");
al.add("Array_04");
//2，打印原集合
sop("打印原集合："+al);
//3，打印集合的长度。集合元素。
sop("打印集合长度："+al.size());
//4，删除元素
al.remove("Array_02");
sop("打印删除后的集合："+al);
//5，清空集合容器
al.clear();
//6，判断元素。
sop("Array_03是否存在："+al.contains("Array_03"));
sop("集合是否为空？"+al.isEmpty());
}
public static void Method_2()
{
ArrayList al1 = new ArrayList();
al1.add("Array_01");
al1.add("Array_02");
al1.add("Array_03");
al1.add("Array_04");
ArrayList al2 = new ArrayList();
al2.add("Array_01");
al2.add("Array_02");
al2.add("Array_05");
al2.add("Array_06");
//al1.retainAll(al2);//取交集，al1 只会保留al2中相同的元素
//al1.removeAll(al2);//取交集，al1 只去除与al2中相同的元素
//al1.addAll(al2);//将al2中的元素，全部放到al1容器中去。
//al1.containsAll(al2);
sop("al1:"+al1);
sop("al2:"+al2);
}
//打印
public static void sop(Object obj)
{
System.out.println(obj);
}
}
迭代器
迭代注意事项
l 迭代器在Collcection接口中是通用的，它替 代了Vector类中的Enumeration(枚举)。
l 迭代器的next方法是自动向下取元素，要避 免出现NoSuchElementException。
l 迭代器的next方法返回值类型是Object，所 以要记得类型转换。
/*
* 1, add方法的参数类型是Object. 以便于接收任意类型对象。
* 2，集合中存储的都是对象的引用（地址）
* ---------------------------------------------------
* 什么是迭代器呢？
* 其实就是集合的取出元素的方式。
*/
public class _03_迭代器 {
public static void main(String[]args)
{
Get();
}
public static void Get()
{
ArrayList a1 = new ArrayList();
//添加元素
a1.add("Java_01");//add(Object obj);
a1.add("Java_02");
a1.add("Java_03");
a1.add("Java_04");
//获取迭代器，用于取出集合中的元素
Iterator it = a1.iterator();
while(it.hasNext())
{
sop(it.next());
}
/*
//节省内存的方式For循环
for(Iterator it = a1.iterator();it.hasNext();)
{
sop(it.next());
}
*/
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
List集合共性方法
/* List集合共性方法
* --------------------------------------------------
* Collection
* |--List: 元素是有序的，元素可以重复，该集合体系有索引。
* |--ArrayList: 底层的数据结构使用的数组结构（特点：查询速度快,但是增删稍慢。线程不同步。因为走角标）
* |--LikedList: 底层使用的是链表数据结构（特点：增删速度很快，查询速度稍慢）
* |--Vector: 底层是数组数据结构。线程同步。被ArrayList替代了。
* |--Set : 元素是无序的，元素不可以重复。
*
* List特有方法：
* 增
* add(index,element);
* addAll(index,Collection);
* 删
* remove(index);
* 改
* set(index,element);
* 查
* get(index);
* subList(from,to);
* ListIterator();
*/
public class _04_List集合共性方法 {
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[]args)
{
ArrayList a1 = new ArrayList();
//添加元素
a1.add("java01");
a1.add("java02");
a1.add("java03");
sop("原集合："+a1);
//指定位置添加元素
a1.add(1,"java09");
a1.add(3,"Java007");
sop("添加后集合："+a1);
//删除元素
a1.remove(1);
sop("删除后集合："+a1);
//修改元素
a1.set(1, "java007");
//通过角标获取元素
sop("根据角标获取元素"+a1.get(2));
//注意：获取所有元素(size()是获取ArrayList的长度，不是使用length获取)
for(int x = 0;x<a1.size();x++)
{
sop("a1("+x+")="+a1.get(x));
}
//第二种获取所有元素的方式（迭代器）
Iterator it = a1.iterator();//a1.iterator（是获取对象a1的迭代）
while(it.hasNext())
{
sop(it.next());
}
//通过indexOf / subList(Start,End)获取对象的角标位置
sop("通过对象获取对象的角标位置："+a1.indexOf("java03"));
List sub = a1.subList(1,4);
sop("通过subList获取对象："+sub);
}
}
ListIterator列表迭代器
import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
/*
* List集合特有的迭代器，ListIterator是Iterator的子接口。
*
* 在迭代时，不可以通过集合对象的方法操作集合中的元素。
* 因为会发生ConcurrentModificationException异常。
*
* 所以，在迭代器时，只能用迭代器的方法操作元素，可是Iterator方法是有限的。
* 只能对元素判断、取出，删除的操作。
*
* ------------------------------------------------------------------------------------
* 迭代器：ListIterator --> List集合特有的迭代器
*
* （特有方法）指定位置add添加、set修改，还能判断前面是否还有元素hasPrevious
* 如果想要其他的操作，如添加，修改,判断前面是否还有元素等，就需要使用其子接口ListIterator。
*
* 原因：ArrayList是数组结构，具有角标，所以可以索取指定角标进行添加修改
* ------------------------------------------------------------------------------------
* 该接口只能通过List集合的ListIterator方法获取。
*/
public class _05_ListIterator列表迭代器 {
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[]args)
{
//演示列表迭代器
ArrayList al = new ArrayList();
//添加元素
al.add("Array01");
al.add("Array02");
al.add("Array03");
sop("原集合元素："+al);
ListIterator li = al.listIterator();
//判断前面是否有元素( hasPrevious() )
sop("hasPrevious:--"+li.hasPrevious());
while(li.hasNext())
{
Object obj = li.next();//此行代码示意：用于接收我们添加的"集合元素"Java007
if(obj.equals("Array02"))
{
//li.add("Java007");//添加
li.set("JAVA02"); //修改
}
}
sop("使用ListIterator列表集合添加后："+al);
//判断后面是否还有元素、false/true
sop("hasNext:--"+li.hasNext());
//判断前面是否有元素( hasPrevious() )
sop("hasPrevious:--"+li.hasPrevious());
//使用hasPervious循环输出
while(li.hasPrevious())
{
sop("hasPrevious:"+li.previous());//输出方式：逆向输出
}
/*-------------------------------------------------------
//通过Iterator方式获取
//在迭代过程中，准备添加或者删除元素
Iterator it = al.iterator();
while(it.hasNext())
{
Object obj = it.next();
if(obj.equals("Array02"))
{
//al.add("Array08");
it.remove();//将Array02的引用从集合中删除了。
}
sop("Obj:"+obj);
}
sop(al);
*/
}
}
LikedList
/*
* LikedList特有方法：
*
* addFirst();
* addLast();
* 添加元素
*
* getFirst();
* getLast();
* 获取元素，但不删除元素，如果集合中没有元素，则会出现NoSuchElementException
*
* removeFirst();
* removeLast();
* 获取元素，但是元素被删除，如果集合中没有元素，则会出现NoSuchElementException
*
* 在JDK1.6以后，出现了替代方法
*
* offerFirst();
* offerLast();
*
* peekFirst();
* peekLast();
* 获取元素，但不删除元素，如果集合中没有元素，则返回null.
*
* pollFirst();
* pollLast();
* 获取元素，但元素被删除，如果集合中没有元素，则返回null
*
*/
import java.util.*;
public class _07_LikedList {
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[]args)
{
LinkedList link = new LinkedList();
//link.addFirst("java01");
//link.addFirst("java02");
//link.addFirst("java03");
//link.addFirst("java04");
//sop(link);
link.addLast("java01");
link.addLast("java02");
link.addLast("java03");
link.addLast("java04");
sop(link);
sop("取头:"+link.getFirst());//取头
sop("取尾："+link.getLast());//取尾
sop("删头："+link.removeFirst());//删头
sop("删尾"+link.removeLast());//删尾
sop("长度："+link.size());//长度
//判断：元素不为空，将元素一一打印并移除
while(!link.isEmpty())
{
//sop(link.removeFirst());//从头到尾打印
sop(link.pollFirst()); //替代removeFirst();
}
}
}
Set集合
HashSet
* |--Set : 元素是无序的(存入和取出的顺序，不一定一致)，元素不可以重复。
* |--HashSet: 底层数据结构是哈希表
* HashSet是如何保证元素唯一性呢？
* 是通过元素的两个方法，hashCode和Equals来完成
* 如果元素的HashCode值相同，才会判断equalse是否为true;
* 如果元素的HashCode值不同，不会调用equalse
*
* －－－－－－－－－结论：对于判断元素是否存在，以及删除等操作，依赖的方法是元素的
* HashCode和equals方法。
* |--TreeSet:
*
* Set的功能与Conllection的方法一样。
*
*/
import java.util.*;
public class _11_HashSet {
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[]args)
{
HashSet hs = new HashSet();
sop(hs.add("java01"));
sop(hs.add("java01"));
hs.add("java02");
hs.add("java03");
hs.add("java04");
Iterator it = hs.iterator();
while(it.hasNext())
{
sop(it.next());
}
}
}
TreeSet Comparator接口比较器排序
/*
* TreeSet第二种排序方式：使用比较器排序
*
* 当元素自身不具备比较性时，或者具备的比较性不是所需要的，
* 这时就需要让集合自身具备比较性。
*
* 让集合一初始化时，就有了比较性。
*
* 定义一个比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。
*
* 当两种排序都存在时，以比较器为主。
*
* 定义比较器怎么定义？
* 定义一个类，实现comparetor接口，覆盖compare方法。
class MyCompare implements Comparator
{
public int compare(Object o1,Object o2)
{
Students s1 = (Students)o1;
Students s2 = (Students)o2;
int num = new Integer(s1.getName().length()).compareTo(s2.getName().length());
if(num==0)
return s1.compareTo(s1);
return num;
}
}
*/
public class _13_TreeSet_comparetor接口 {
public static void main(String[]args)
{
TreeSet ts = new TreeSet(new Mycompare());//指定使用比较器进行排序
ts.add(new StuTwo("lisi01",32));
ts.add(new StuTwo("lisi007",33));
ts.add(new StuTwo("lisi06",30));
ts.add(new StuTwo("lisi08",31));
Iterator it = ts.iterator();
while(it.hasNext())
{
StuTwo s = (StuTwo)it.next();
System.out.println(s.getAge()+".."+s.getName());
}
}
}
class Mycompare implements Comparator
{
public int compare(Object o1,Object o2)
{
StuTwo s1 = (StuTwo)o1;
StuTwo s2 = (StuTwo)o2;
int num = s1.getName().compareTo(s2.getName());
//如果主要条件相同，也就是等于0，就判断次要条件，
if(num==0)
{
/*//第一种方式
if(s1.getAge()>s2.getAge())
{
return 1;
}
if(s1.getAge()==s2.getAge())
{
return 0;
}
return -1;
*/
//第二种方式
return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
}
return num;
}
}
class StuTwo
{
private String name;
private int age;
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
StuTwo(String name,int age)
{
this.name=name;
this.age=age;
}
public int compareTo(Object obj)
{
if(!(obj instanceof StuTwo))
{
throw new RuntimeException("不是学生对象");
}
StuTwo st = (StuTwo)obj;
if(this.age>st.age)
{
return 1;
}
if(this.age==st.age)
{
//注意：这里的compareTo是String自身已经实现了compareTo方法，字符串自身具备比较性和排序功能
return this.name.compareTo(st.getName());
}
return -1;
}
}
TreeSet (Comparable接口)
使用TreeSet集合时，添加对象元素时，
必须实现comparable接口，这样才能进行多个对象的排序。
并且要覆盖comparable接口的compareTo方法，
如果主要条件相同this.age==s.age，就要判断次要条件(returnthis.name.compareTo(s.name);
字符串本身就具备compareTo排序方法。
例如：以年龄大小进行排序，如果年龄相同，就要判断名字是否相同。
/*
* Set: 无序，不可以重复元素。
* |--HashSet:数据结构是哈希表，线程是非同步的。
* 保证元素唯一性的原理，判断元素的HashCode是否相同
* 如果相同，还会继续判断元素的equals方法，是否为true
* |--TreeSet：可以对Set集合中的元素进行排序
*
* 需求：
* 往Treeset集合中存储自定义对象学生。
* 想按照学生的年龄进行排序
*
* 注意：当主要排序条件成立时，再判断次要条件
*
*/
public class _13_TreeSet {
public static void main(String[]arsg)
{
TreeSet ts = new TreeSet();
ts.add(new Student("lisi02",33));
ts.add(new Student("lisi04",34));
ts.add(new Student("lisi007",35));
ts.add(new Student("lisi01",36));
Iterator it = ts.iterator();
while(it.hasNext())
{
Student stu = (Student)it.next();
System.out.println(stu.getName()+"..."+stu.getAge());
}
}
}
class Student implements Comparable
{
private String name;
public String getName()
{
return name;
}
private int age;
public int getAge()
{
return age;
}
Student(String name,int age)
{
this.name=name;
this.age=age;
}
public int comparaTo(Object obj)
{
if(!(obj instanceof Student))
{
throw new RuntimeException("不是学生对象");
}
Student s = (Student)obj;
System.out.println(this.name+"...comparato"+s.name);
if(this.age>s.age)
{
return 1;
}
if(this.age==s.age)
{
return this.name.compareTo(s.name);//按照字符串进行排序
}
return -1;
}
}
---------------------- 黑马程序员 Android培训、期待与您交流！ ----------------------
562
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
