黑马程序员技术交流社区

标题: 分享-java集合框架总结1 [打印本页]

作者: viliv715 时间: 2014-9-2 20:26
标题: 分享-java集合框架总结1
本帖最后由 viliv715 于 2014-9-2 20:29 编辑

集合框架和泛型

一、集合框架

为什么出现集合类？

面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。

数组和集合同是容器，有何不同？

数组虽然也可以存储对象，但是长度是固定的，而集合的长度是可变的。数组中可以存储基本数据类型，但集合只能存储对象。

集合类的特点：

集合只能用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。

集合类关系图：重点掌握部分黑框表示。

为什么容器有这么多的划分？

因为每一个容器中对数据存储的方式不同，也就是说数据结构不同。

1、collection单列集合

Collection(参照CollectionDemo.java)

|---List(参照ListDemo.java)：元素是有序的，元素可以重复，因为该集合体系有索引。

|---ArrayList(参照CollectionDemo.java或ListDemo.java)：底层使用数组结构，查询速度快，增删速度较慢。线程不同步。

|---LinkedList(参照LinkedListDemo.java)：使用链表结构，增删速度快，查询较慢，线程不同步。

|---Vector(参照VectorDemo.java)：底层使用的是数组结构，线程同步，被ArrayList取代。

|---Set：元素是无序(存入和取出的顺序不一定一致)的，元素不可以重复。

|---HashSet(参照HashSetDemo.java)底层数据结构式哈希表。

| |--元素唯一性的原因：通过hashCode和equals方法判断，如果hashCode值不同不调

| 用equals，hashCode值相同，调用equals方法。对于判断元素是否存在，以及删

| 除操作，也是依赖于hashCode和equals方法。线程不同步。

|---TreeSet(参照TreeSetDemo.java)底层数据结构式二叉树。可以对集合中的元素进行排序。线

程不同步。

|--元素唯一性原因：用compareTo方法比较。

|--TreeSet排序方式1：让元素自身具备比较性，元素需要实现Comparable接口并要

覆盖compareTo方法。

|--TreeSet排序方式2：当元素自身不具备比较性或者比较性不是所需要的，这时候需

要让集合容器自身具有比较性。定义一个类实现comparator接口并覆盖

compare方法。两种比较方法都存在以该比较器为主。

2、Map：双列集合，该集合存储的是键值对，一对对的存储，且必须保证键的唯一性。

Map：

|---HashTable：底层是哈希表结构，不允许使用NULL的键和值，该集合是同步的。

|---HashMap：底层是哈希表结构，允许使用NULL的键和值，该集合是不同步的。

|---TreeMap：底层是二叉树结构，线程不同步。可以用于给Map集合中的键进行排序。

二、泛型

JDK1.5之后，为了解决安全问题出现的新特性。

泛型优点：

将运行时期出现的问题转移到了编译时期，方便解决。

避免了类型的强制转换

泛型格式：

通过<>来定义要操作的类型，泛型定义在方法上时，写在返回值类型的前面，修饰符的后面。

泛型使用范围：

通常用在集合框架中，只要出现<>就要定义泛型。

泛型类和泛型方法：参考GenericMethodDemo.java

泛型接口：参考GenericInterDemo.java

泛型限定：参考GenericLimitDemo.java

代码实例：

CollectionDemo.java

package day14;
//collection常用方法
import java.util.*;
public class CollectionDemo {
public static void main(String[] args) {
// baseMethod();
// advMethod();
// getMethod();
}
//基本方法
public static void baseMethod()
{
// 创建一个集合容器，使用collection接口的子类ArrayList
ArrayList al = new ArrayList();
//添加元素
//add方法的参数类型是object，便于接收任意类型对象；集合中存储的都是对象的引用（地址）
al.add("java1");
al.add("java2");
al.add("java3");
al.add("java4");
//获取集合长度
sop("size：" + al.size());
//打印
sop(al);
//删除元素
al.remove("java2");
//清空集合
al.clear();
//判断元素
sop("判断java1是否存在:"+al.contains("java1"));
sop("判断集合是否为空:"+al.isEmpty());
}
//其他方法
public static void advMethod()
{
ArrayList al1 = new ArrayList();
al1.add("java1");
al1.add("java2");
al1.add("java3");
al1.add("java4");
ArrayList al2 = new ArrayList();
al2.add("java1");
al2.add("java3");
al2.add("java5");
al2.add("java6");
//取交集：al1与al2的交集存放到al1中
al1.retainAll(al2);
sop("al1"+al1);
sop("al2"+al2);
}
//迭代器方法：是集合取出元素的方式
public static void getMethod()
{
ArrayList al = new ArrayList();
al.add("java1");
al.add("java2");
al.add("java3");
al.add("java4");
//获取迭代器，用于取出集合中的元素，在迭代时next调用一次就要判断一次hasNext。
//while方式
Iterator it = al.iterator();
while(it.hasNext())//判断是否存在下一个元素
sop(it.next());//返回下一个元素
//for方式：it2属于for内部，循环完释放空间。
for(Iterator it2 = al.iterator();it2.hasNext();)
sop(it2.next());
}
public static void sop(Object obj){
System.out.println(obj);
}
}

复制代码

作者: viliv715 时间: 2014-9-2 20:40
ListDemo.java

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
/*
List特有方法：凡是可以操作角标的方法都是该体系特有的方法
增
add(index,element)指定位置添加元素
addAll(index,collection)指定位置添加集合
删
remove(index)删除指定位置元素
改
set(index,element)：修改指定位置元素
查
get(index)：获取指定位置元素
subList(from,to)：获取子集，包含头不包含尾
listIterator()：List特有的迭代器，是Iterator的子接口。在迭代时不可以通过集合对象的
方法操作集合中的元素，会发生并发修改异常。所以在迭代时，只能用迭代器的方法操作元素，可是
Iterator的方法是有限的，只能对元素进行判断，取出和删除，如果想要其他的操作，如添加修改等
就需要使用其子接口listIterator，该接口只能通过List集合的listIterator方法获取
注意：List集合判断元素是否相同，依据的是元素的equals方法，contains和remove方法在底层都是
调用equals方法，自定义元素判断时需要复写equals方法。
*/
public class ListDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
// method();
itmethod();
}
//list基本方法
public static void method(){
ArrayList al = new ArrayList();
al.add("java1");
al.add("java2");
al.add("java3");
//在指定位置添加元素
al.add(1,"java9");
//删除指定位置的元素
al.remove(2);
//修改元素
al.set(2, "java7");
//通过角标获取元素
sop(al.get(1));
//获取所有元素
//方法1
for(int x=0;x<al.size();x++)
{
sop(al.get(x));
}
//方法2
Iterator it =al.iterator();
while(it.hasNext())
{
sop(it.next());
}
//通过indexOf获取对象的位置
sop("indexOf"+al.indexOf("java7"));
//获取子List
List sublist = al.subList(0,2);
sop("sublist:"+sublist);
}
//列表迭代器
public static void itmethod(){
ArrayList al = new ArrayList();
al.add("java1");
al.add("java2");
al.add("java3");
ListIterator li = al.listIterator();
while(li.hasNext())
{
Object obj = li.next();
if(obj.equals("java2"))
{
li.add("java9");
}
}
//判断是否有前一个元素，与hasNext相反
sop("hasPrevious:"+li.hasPrevious());
sop(al);
}
public static void sop(Object obj){
System.out.println(obj);
}
}

复制代码

LinkedListDemo.java

import java.util.*;
/*
LinkedList特有方法：
addFirst():添加元素到头部
addLast():添加元素到尾部
注意：以下四个方法若列表为空，返回NoSuchElementException异常
getFirst():获取第一个元素但是不删除元素
getLast():获取最后一个元素但是不删除元素
removeFirst():获取第一个元素并删除元素
removeLast():获取最后一个元素并删除元素
JDK1.6后新增方法，建议用新增方法替代上述方法
offerFirst():添加元素到头部
OfferLast():添加元素到尾部
注意：以下四个方法若列表为空，返回NULL
peekFirst():获取第一个元素但是不删除元素
peekLast():获取最后一个元素但是不删除元素
pollFirst():获取第一个元素并删除元素
pollLast():获取最后一个元素并删除元素
*/
public class LinkedListDemo {
public static void main(String[] args) {
LinkedList link = new LinkedList();
//在头部添加元素
link.addFirst("java1");
link.addFirst("java2");
//在尾部添加元素
link.addLast("java3");
link.addLast("java4");
sop(link);
//获取第一个元素
sop(link.getFirst());
//获取最后一个元素
sop(link.getLast());
//删除第一个元素
sop(link.removeFirst());
//删除最后一个元素
sop(link.removeLast());
//获取集合长度
sop("size:"+link.size());
//特有方法清空集合
while(!link.isEmpty())
{
sop(link.removeFirst());
}
}
public static void sop(Object obj){
System.out.println(obj);
}
}

复制代码

VectorDemo.java

import java.util.Enumeration;
import java.util.Vector;
public class VectorDemo {
public static void main(String[] args) {
Vector v = new Vector();
v.add("java1");
v.add("java2");
v.add("java3");
v.add("java4");
//枚举是vector特有的取出方式。因为枚举的名称过长，被迭代器锁取代。
Enumeration en = v.elements();
while(en.hasMoreElements())
{
sop(en.nextElement());
}
}
public static void sop(Object obj){
System.out.println(obj);
}
}

复制代码

HashSetDemo.java

import java.util.HashSet;
import java.util.Iterator;
public class HashSetDemo {
public static void main(String[] args) {
// method_1();
method_2();
}
//查看hashset基本特点，无需无重复元素。
public static void method_1(){
HashSet hs = new HashSet();
//添加数据，重复的数据不存储。
sop(hs.add("java1"));
sop(hs.add("java1"));
hs.add("java2");
hs.add("java3");
hs.add("java4");
hs.add("java4");
Iterator it = hs.iterator();
//打印出的数据时无序的
while(it.hasNext())
{
sop(it.next());
}
}
//去除自定义对象的重复元素
public static void method_2(){
HashSet hs = new HashSet();
hs.add(new Person("a1", 11));
hs.add(new Person("a1", 11));
hs.add(new Person("a2", 12));
hs.add(new Person("a3", 13));
hs.add(new Person("a4", 14));
Iterator it = hs.iterator();
while(it.hasNext())
{
Person p = (Person)it.next();
sop(p.getName()+"----"+p.getAge());
}
}
public static void sop(Object obj){
System.out.println(obj);
}
}
class Person
{
private String name;
private int age;
public Person(String name,int age) {
this.name=name;
this.age=age;
}
public int hashCode()
{
return name.hashCode()+age;
}
public boolean equals(Object obj)
{
if(!(obj instanceof Person))
return false;
Person p = (Person)obj;
return this.name.equals(p.name)&&this.age==p.age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}

复制代码

TreeSetDemo.java

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
import javax.swing.SwingConstants;
public class TreeSetDemo {
public static void main(String[] args) {
// TreeSet ts = new TreeSet();
//排序方式2
TreeSet ts = new TreeSet(new MyCompare());
ts.add(new Student("lisi8", 21));
ts.add(new Student("lisi8", 24));
ts.add(new Student("lisi2", 22));
ts.add(new Student("lisi3", 23));
ts.add(new Student("lisi5", 23));
ts.add(new Student("lisi4", 24));
Iterator it = ts.iterator();
while(it.hasNext())
{
Student stu = (Student)it.next();
sop(stu.getName()+"----"+stu.getAge());
}
}
public static void sop(Object obj){
System.out.println(obj);
}
}
//排序方式1：让元素自身具备比较性，元素需要实现Comparable接口并要覆盖compareTo方法。
class Student implements Comparable//该接口强制让学生具备比较性
{
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;
}
public int compareTo(Object obj){
if(!(obj instanceof Student))
throw new RuntimeException("不是学生对象");
Student stu = (Student)obj;
if(this.age>stu.age)
return 1;
if(this.age==stu.age)
//主要条件相同时比较次要条件。String复写了compareTo
return this.name.compareTo(stu.name);
return -1;
//return this.age-stu.age;
}
}
//排序方式2：当元素自身不具备比较性或者比较性不是所需要的，这时候需
//要让集合容器自身具有比较性
class MyCompare implements Comparator//该接口强制让学生具备比较性
{
public int compare(Object o1,Object o2){
Student s1=(Student)o1;
Student s2=(Student)o2;
int num = s1.getName().compareTo(s2.getName());
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;
}
//不用覆盖equals方法，object已经实现了equals方法。
}

复制代码

作者: viliv715 时间: 2014-9-2 20:45
GenericMethodDemo.java

/*泛型方法
泛型类定义的泛型，在整个类中有效，那么泛型类的对象明确要操作的类型后
所要操作的类型就已经固定了。为了让不同方法可以操作不同类型，而且类型
还不确定，那么可以将泛型定义在方法上，既是泛型方法。
*/
public class GenericMethodDemo {
public static void main(String[] args) {
Demo<String> d = new Demo<String>();
d.show("show string");
d.print("print string");
d.print(new Integer(5));
d.method("hiehei");
}
}
//泛型方法和泛型类可以同时定义。
class Demo <T>
{
public void show(T t){
System.out.println(t);
}
public <Q> void print(Q t){
System.out.println(t);
}
//public static void method(T t)
//特殊点：静态方法不可以访问类上定义的泛型。
//如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。
public static <W> void method(W w)
{
System.out.println(w);
}
}

复制代码

GenericInterDemo.java

//泛型接口
public class GenericInterDemo {
public static void main(String[] args) {
InterImpl<Integer> i = new InterImpl<Integer>();
i.show(6);
}
}
interface Inter<T>
{
void show(T t);
}
class InterImpl<T> implements Inter<T>
{
public void show(T t) {
System.out.println(t);
}
}

复制代码

GenericLimitDemo.java

import java.util.ArrayList;
import java.util.Iterator;
/*
?是通配符，也可以理解为占位符。
? extends E:可以接受E类型或者E的子类型。
? super E：可以接受E类型或者E的父类型。
*/
public class GenericLimitDemo {
public static void main(String[] args) {
ArrayList<Person> al = new ArrayList<Person>();
al.add(new Person("aaa1"));
al.add(new Person("aaa2"));
al.add(new Person("aaa3"));
printColl(al);
ArrayList<Student> al2 = new ArrayList<Student>();
al2.add(new Student("bbb1"));
al2.add(new Student("bbb2"));
al2.add(new Student("bbb3"));
printColl(al2);
}
public static void printColl(ArrayList<? extends Person> al){
Iterator<? extends Person> it = al.iterator();
while(it.hasNext())
{
System.out.println(it.next().getName());
}
}
}
class Person
{
private String name;
Person(String name){
this.name = name;
}
public String getName(){
return name;
}
}
class Student extends Person
{
Student(String name)
{
super(name);
}
}

复制代码

作者: ☆枫の云 时间: 2014-9-2 20:54
我是来看楼主头像的，强迫症的伤不起！！

作者: 七丶哥 时间: 2014-9-2 21:16
很详细啊，看看吧，

作者: 天黑偷牛 时间: 2014-9-2 21:46
我勒个去

作者: 范鹏霄 时间: 2014-9-2 21:49
挺好的，不错

作者: viliv715 时间: 2014-9-3 08:35

天黑偷牛发表于 2014-9-2 21:46
我勒个去

帖子最大字数10000 放不下只能在楼下回复了回复框那么小贴代码好麻烦啊

作者: viliv715 时间: 2014-9-3 08:40

☆枫の云发表于 2014-9-2 20:54
我是来看楼主头像的，强迫症的伤不起！！

要的就是这个感觉--倍儿爽！

作者: 菜鸟一号 时间: 2014-9-3 09:08
我那个去，就是毕老师笔记的搬抄

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2