java学习——集合框架(Collection,List,Set)

集合类的由来：
对象用于封装特有数据，对象多了需要存储，如果对象的个数不确定,就使用集合容器进行存储。

集合特点：
1，用于存储对象的容器。
2，集合的长度是可变的。
3，集合中不可以存储基本数据类型值。

集合容器因为内部的数据结构不同，有多种具体容器。
不断的向上抽取，就形成了集合框架。

框架的顶层Collection接口：java.util

Collection的常见方法：

1，添加。
boolean add(Object obj):

boolean addAll(Collection coll):

2，删除。
boolean remove(object obj):
boolean removeAll(Collection coll);
void clear();

3，判断：
boolean contains(object obj):
boolean containsAll(Colllection coll);
boolean isEmpty():判断集合中是否有元素。

package cn.itcast.p3.collection.demo;
 
import java.util.ArrayList;
import java.util.Collection;
 
public class CollectionDemo {
 
    public static void main(String[] args) {
        Collection coll = new ArrayList();
 
        show(coll);
 
    }
 
    public static void show(Collection coll){
 
        //1,添加元素。add.
        coll.add("abc1");
        coll.add("abc2");
        coll.add("abc3");
        System.out.println(coll);    
 
        //2，删除元素。remove
//        coll.remove("abc2");//会改变集合的长度 
 
        //清空集合.
//        coll.clear();
 
        System.out.println(coll.contains("abc3"));
 
        System.out.println(coll);
 
    }
 
}

package cn.itcast.p3.collection.demo;
 
import java.util.ArrayList;
import java.util.Collection;
 
public class CollectionDemo {
 
    /**
     * @param args
     */
    public static void main(String[] args) {
        Collection coll = new ArrayList();
 
        Collection c1 = new ArrayList();
        Collection c2 = new ArrayList();
        show(c1,c2);
 
    }
 
    public static void show(Collection c1,Collection c2){
 
        //给c1添加元素。
        c1.add("abc1");
        c1.add("abc2");
        c1.add("abc3");
        c1.add("abc4");
 
        //给c2添加元素。
        c2.add("abc1");
        c2.add("abc2");
        c2.add("abc3");
        c2.add("abc4");
        c2.add("abc5");
 
        System.out.println("c1:"+c1);
        System.out.println("c2:"+c2);
 
        //演示addAll
 
//        c1.addAll(c2);//将c2中的元素添加到c1中。
 
        //演示removeAll
//        boolean b = c1.removeAll(c2);//将两个集合中的相同元素从调用removeAll的集合中删除。
//        System.out.println("removeAll:"+b);
 
        //演示containsAll
//        boolean b = c1.containsAll(c2);
//        System.out.println("containsAll:"+b);
 
        //演示retainAll
        boolean b = c1.retainAll(c2);//取交集，保留和指定的集合相同的元素，而删除不同的元素。
                                //和removeAll功能相反 。
        System.out.println("retainAll:"+b);
        System.out.println("c1:"+c1);
    }
}

4，获取：
int size():
Iterator iterator():取出元素的方式：迭代器。
该对象必须依赖于具体容器，因为每一个容器的数据结构都不同。
所以该迭代器对象是在容器中进行内部实现的。
对于使用容器者而言，具体的实现不重要，只要通过容器获取到该实现的迭代器的对象即可，
也就是iterator方法。

Iterator接口就是对所有的Collection容器进行元素取出的公共接口。
其实就是抓娃娃游戏机中的夹子！

package cn.itcast.p3.collection.demo;
 
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
 
public class IteratorDemo {
    public static void main(String[] args) {
 
        Collection coll = new ArrayList();
        coll.add("abc1");
        coll.add("abc2");
        coll.add("abc3");
        coll.add("abc4");
 
//        System.out.println(coll);
 
        //使用了Collection中的iterator()方法。 调用集合中的迭代器方法，是为了获取集合中的迭代器对象。
//        Iterator it = coll.iterator();
//        while(it.hasNext()){
//            System.out.println(it.next());
//        }
 
        for(Iterator it = coll.iterator(); it.hasNext(); ){
            System.out.println(it.next());
        }
    }
}

5，其他：
boolean retainAll(Collection coll);取交集。
Object[] toArray():将集合转成数组。

-------------------------------
Collection
|--List：有序(存入和取出的顺序一致),元素都有索引(角标)，元素可以重复。
|--Set：元素不能重复,无序。

List:特有的常见方法：有一个共性特点就是都可以操作角标。

1，添加
void add(index,element);
void add(index,collection);

2，删除；
Object remove(index):

3，修改：
Object set(index,element);

4，获取：
Object get(index);
int indexOf(object);
int lastIndexOf(object);
List subList(from,to);

list集合是可以完成对元素的增删改查。

package cn.itcast.p4.list.demo;
import java.util.ArrayList;
import java.util.List;
 
public class ListDemo {
    public static void main(String[] args) {
        List list = new ArrayList();
        show(list);
    }
    public static void show(List list) {
        //添加元素
        list.add("abc1");
        list.add("abc2");
        list.add("abc3");
        System.out.println(list);
 
        //插入元素。
//        list.add(1,"abc9");
        //删除元素。
//        System.out.println("remove:"+list.remove(2));
        //修改元素。
//        System.out.println("set:"+list.set(1, "abc8"));
        //获取元素。
//        System.out.println("get:"+list.get(0));
        //获取子列表。
//        System.out.println("sublist:"+list.subList(1, 2));
        System.out.println(list);
    }
}

package cn.itcast.p4.list.demo;
 
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
 
public class ListDemo2 {
 
    /**
     * @param args
     */
    public static void main(String[] args) {
 
        List list = new ArrayList();
        show(list);
    }
    public static void show(List list) {
 
        list.add("abc1");
        list.add("abc2");
        list.add("abc3");
        list.add("abc4");
 
        Iterator it = list.iterator();
        while(it.hasNext()){
            System.out.println("next:"+it.next());
        }
        //list特有的取出元素的方式之一。
 
        for(int x=0; x<list.size(); x++){
            System.out.println("get:"+list.get(x));
        }
    }
}

public class ListDemo2 {
 
    public static void main(String[] args) {
 
        List list = new ArrayList();
 
        list.add("abc1");
        list.add("abc2");
        list.add("abc3");
 
        System.out.println("list:"+list);
               //Iterator接口的子接口ListIterator来完成在迭代中对元素进行更多的操作。
        ListIterator it = list.listIterator();
                //获取列表迭代器对象
        //它可以实现在迭代过程中完成对元素的增删改查。
        //注意：只有list集合具备该迭代功能.
 
        while(it.hasNext()){
            Object obj = it.next();
            if(obj.equals("abc2")){
                it.set("abc9");
            }
        }
//        System.out.println("hasNext:"+it.hasNext());
//        System.out.println("hasPrevious:"+it.hasPrevious());
 
        //逆向遍历
        while(it.hasPrevious()){
            System.out.println("previous:"+it.previous());
        }
        System.out.println("list:"+list);
 
}

List:
|--Vector:内部是数组数据结构，是同步的。增删，查询都很慢！(不用了)
|--ArrayList:内部是数组数据结构，是不同步的。替代了Vector。查询的速度快。
|--LinkedList:内部是链表数据结构，是不同步的。增删元素的速度很快。

Vector举例：

public class VectorDemo {
    public static void main(String[] args) {
        Vector v = new Vector();
        v.addElement("abc1");
        v.addElement("abc2");
        v.addElement("abc3");
        v.addElement("abc4");
        Enumeration en = v.elements();
        while(en.hasMoreElements()){
            System.out.println("nextelment:"+en.nextElement());
        }
        //Enumeration接口与Iterator接口功能是重复的。
        Iterator it = v.iterator();
        while(it.hasNext()){
            System.out.println("next:"+it.next());
        }
    }
}

LinkedList举例：查api

public class LinkedListDemo {
    public static void main(String[] args) {
 
        LinkedList link = new LinkedList();
        link.addFirst("abc1");
        link.addFirst("abc2");
        link.addFirst("abc3");
        link.addFirst("abc4");
//        System.out.println(link);
//        System.out.println(link.getFirst());//获取第一个但不删除。
//        System.out.println(link.getFirst());
 
//        System.out.println(link.removeFirst());//获取元素但是会删除。
//        System.out.println(link.removeFirst());
        while(!link.isEmpty()){
            System.out.println(link.removeLast());
        }
 
        System.out.println(link);
//        Iterator it = link.iterator();
//        while(it.hasNext()){
//            System.out.println(it.next());
//        }
    }
}

ArrayList示例：

public class ArrayListTest {
    public static void main(String[] args) {
        Person p1 = new Person("lisi1",21);
        ArrayList al = new ArrayList();
        al.add(p1);
        al.add(new Person("lisi2",22));
        al.add(new Person("lisi3",23));
        al.add(new Person("lisi4",24));
        Iterator it = al.iterator();
        while(it.hasNext()){
            Person p = (Person) it.next();
            System.out.println(p.getName()+"--"+p.getAge());
        }
    }
}

Set:

元素不可以重复，是无序。
Set接口中的方法和Collection一致。
|--HashSet: 内部数据结构是哈希表，是不同步的。
如何保证该集合的元素唯一性呢？
是通过对象的hashCode和equals方法来完成对象唯一性的。
如果对象的hashCode值不同，那么不用判断equals方法，就直接存储到哈希表中。
如果对象的hashCode值相同，那么要再次判断对象的equals方法是否为true。
如果为true，视为相同元素，不存。如果为false，那么视为不同元素，就进行存储。

记住：如果元素要存储到HashSet集合中，必须覆盖hashCode方法和equals方法。
一般情况下，如果定义的类会产生很多对象，比如人，学生，书，通常都需要覆盖equals，hashCode方法。
建立对象判断是否相同的依据。

示例：

package cn.itcast.p.bean;
 
public class Person extends Object{
    private String name;
    private int age;
    public Person() {
        super();
 
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
 
    @Override
    public int hashCode() {
//        System.out.println(this+".......hashCode");
        return name.hashCode()+age*27;
    }
    @Override
    public boolean equals(Object obj) {
 
        if(this == obj)
            return true;
        if(!(obj instanceof Person))
            throw new ClassCastException("类型错误");
//        System.out.println(this+"....equals....."+obj);
        Person p = (Person)obj;
        return this.name.equals(p.name) && this.age == p.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 String toString(){
        return name+":"+age;
    }
}

package cn.itcast.p4.hashset.test;
import java.util.HashSet;
import java.util.Iterator;
import cn.itcast.p.bean.Person;
/*
 * 往hashSet集合中存储Person对象。如果姓名和年龄相同，视为同一个人。视为相同元素。
 */
public class HashSetTest {
    public static void main(String[] args) {
        HashSet hs = new HashSet();
        /*
         * HashSet集合数据结构是哈希表，所以存储元素的时候，
         * 使用的元素的hashCode方法来确定位置，如果位置相同，在通过元素的equals来确定是否相同。
         *
         */
        hs.add(new Person("lisi4",24));
        hs.add(new Person("lisi7",27));
        hs.add(new Person("lisi1",21));
        hs.add(new Person("lisi9",29));
        hs.add(new Person("lisi7",27));
        Iterator it = hs.iterator();
        while(it.hasNext()){
            Person p = (Person)it.next();
            System.out.println(p);
//            System.out.println(p.getName()+"...."+p.getAge());
        }
    }
}

有序还唯一用子类：LinkedHashSet

|--TreeSet:可以对Set集合中的元素进行排序。是不同步的。
判断元素唯一性的方式：就是根据比较方法的返回结果是否是0，是0，就是相同元素，不存。

TreeSet对元素进行排序的方式一：
让元素自身具备比较功能，元就需要实现Comparable接口。覆盖compareTo方法。

package cn.itcast.p.bean;
public class Person implements Comparable {
    private String name;
    private int age;
    public Person() {
        super();
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = 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 String toString(){
        return name+":"+age;
    }
    @Override
    public int compareTo(Object o) {
 
        Person p = (Person)o;
//按年龄排序
        int  temp = this.age-p.age;
        return temp==0?this.name.compareTo(p.name):temp;
//按姓名排序
//        int  temp = this.name.compareTo(p.name);
//        return temp==0?this.age-p.age:temp;
 
    }
}

package cn.itcast.p5.treeset.demo;
import java.util.Iterator;
import java.util.TreeSet;
import cn.itcast.p.bean.Person;
public class TreeSetDemo {
    public static void main(String[] args) {
        TreeSet ts = new TreeSet();
        ts.add(new Person("zhangsan",28));
        ts.add(new Person("lisi",21));
        ts.add(new Person("zhouqi",29));
        ts.add(new Person("zhaoliu",25));
        ts.add(new Person("wangu",24));
        Iterator it = ts.iterator();
        while(it.hasNext()){
            Person p = (Person)it.next();
        System.out.println(p.getName()+":"+p.getAge());
        }
 
    }
}

如果不要按照对象中具备的自然顺序进行排序。如果对象中不具备自然顺序。怎么办？
可以使用TreeSet集合第二种排序方式二：（常用）
让集合自身具备比较功能，定义一个类实现Comparator接口，覆盖compare方法。
将该类对象作为参数传递给TreeSet集合的构造函数。

package cn.itcast.p5.comparator;
import java.util.Comparator;
import cn.itcast.p.bean.Person;
/**
 * 创建了一个根据Person类的name进行排序的比较器。
 */
public class ComparatorByName implements Comparator {
    @Override
    public int compare(Object o1, Object o2) {
        Person p1 = (Person)o1;
        Person p2 = (Person)o2;
        int temp = p1.getName().compareTo(p2.getName());
        return temp==0?p1.getAge()-p2.getAge(): temp;
    }
}

package cn.itcast.p5.treeset.demo;
import java.util.Iterator;
import java.util.TreeSet;
import cn.itcast.p.bean.Person;
import cn.itcast.p5.comparator.ComparatorByName;
public class TreeSetDemo {
    public static void main(String[] args) {
        TreeSet ts = new TreeSet(new ComparatorByName());
        /*
         * 以Person对象年龄进行从小到大的排序。
         *
         */
        ts.add(new Person("zhangsan",28));
        ts.add(new Person("lisi",21));
        ts.add(new Person("zhouqi",29));
        ts.add(new Person("zhaoliu",25));
        ts.add(new Person("wangu",24));
        Iterator it = ts.iterator();
        while(it.hasNext()){
            Person p = (Person)it.next();
        System.out.println(p.getName()+":"+p.getAge());
        }
    }
}

package cn.itcast.p5.comparator;
import java.util.Comparator;
public class ComparatorByLength implements Comparator {
    @Override
    public int compare(Object o1, Object o2) {
        String s1 = (String)o1;
        String s2 = (String)o2;
        int temp = s1.length()-s2.length();
        return temp==0? s1.compareTo(s2): temp;
    }
}

package cn.itcast.p5.treeset.test;
import java.util.Iterator;
import java.util.TreeSet;
import cn.itcast.p5.comparator.ComparatorByLength;
/*
 * 对字符串进行长度排序。
 *
 * "20 18 -1 89 2 67"
 */
public class TreeSetTest {
    public static void main(String[] args) {
        TreeSet ts = new TreeSet(new ComparatorByLength());
        ts.add("aaaaa");
        ts.add("zz");
        ts.add("nbaq");
        ts.add("cba");
        ts.add("abc");
        Iterator it = ts.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}

if(this.hashCode()== obj.hashCode() && this.equals(obj))

哈希表确定元素是否相同
1，判断的是两个元素的哈希值是否相同。
如果相同，在判断两个对象的内容是否相同。

2，判断哈希值相同，其实判断的是对象的hashCode的方法。判断内容相同，用的是equals方法。

注意：如果哈希值不同，是不需要判断equals。

完毕..

java学习——集合框架(Collection,List,Set)的更多相关文章

Java自学-集合框架 Collection
Java集合框架 Collection Collection是一个接口步骤 1 : Collection Collection是 Set List Queue和 Deque的接口 Queue: 先进 ...
Java学习----集合框架总结
集合框架总结: Collection接口: Set接口: HashSet//对象必须实现hashCode方法,元素没有顺序呢,效率比LinkedHashSet高 LinkedHashSet//是Has ...
Java学习——集合框架【4】
一.集合框架集合框架是一个用来代表和操纵集合的统一架构.所有的集合框架都包含如下内容: 接口:是代表集合的抽象数据类型.接口允许集合独立操纵其代表的细节.在面向对象的语言,接口通常形成一个层次. 实 ...
【转】Java学习---集合框架那些事
[原文]https://www.toutiao.com/i6593220692525711885/ Arraylist 与 LinkedList 异同 1. 是否保证线程安全: ArrayList 和 ...
[Java复习] 集合框架 Collection
Q1 Collection java的集合以及集合之间的继承关系? 数组和链表的区别? 固定长度,连续内存,不能扩展,随机访问快,插入删除慢.链表相反 List, Set, Map的区别? List, ...
java学习——集合框架(泛型，Map)
泛型: ... Map:一次添加一对元素.Collection 一次添加一个元素. Map也称为双列集合,Collection集合称为单列集合. 其实map集合中存储的就是键值对. map集合中必须保 ...
理解java集合——集合框架 Collection、Map
1.概述: @white Java集合就像一种容器,可以把多个对象(实际上是对象的引用,但习惯上都称对象)"丢进"该容器中. 2.Java集合大致可以分4类: @white Set ...
Java集合框架Collection
转自:http://www.cdtarena.com/javapx/201306/8891.html [plain] view plaincopyprint?01.在 Java2中,有一套设计优良的接 ...
Java中的集合框架-Collection（二）
上一篇<Java中的集合框架-Collection(一)>把Java集合框架中的Collection与List及其常用实现类的功能大致记录了一下,本篇接着记录Collection的另一个子 ...

随机推荐

springboot工程读取配置文件application.yml的写法
现在流行springboot框架的项目,里面的默认配置文件为application.yml,我们怎样读取这个配置文件呢? 先贴上我得配置文件吧目录结构里面内容 1 写读取配置文件的工具类 @Con ...
What qualities characterize a great PhD student
省理工计算机教授David Karger接触了许多世界上最杰出的博士生,近日总结出了优秀博士通常具备的五点品质:0 过人的智力 1 好奇心 2 创造力 3 纪律性与生产力 4 与观众沟通 5 与伙伴沟 ...
玩了一下SDN:MININET+FLOODLIGHT，感觉这确实是一个趋势啊
功能用增加中间层的方案来解决. 仿佛回到用交换机和路由器模拟器的感觉. 遇到执行命令小问题,狗哥搞定: mininet>mininet> dpctl dump-flows tcp:127. ...
主席树套树状数组动态区间第k小
先打上代码以后更新解释 #include <cstdio> #include <iostream> #include <algorithm> #include &l ...
C语言中for循环的使用
for循环的作用: 注意:要主要满足条件一和二后是先执行语句,后再执行条件三. 简单重复的输出 for(int i=0:i<10;i++){ printf("对一句话简单重复输出输出1 ...
【索引】gtest学习笔记
下载gtest 链接:http://www.cnblogs.com/duxiuxing/p/4270804.html gtest官方文档浅析链接:http://www.cnblogs.com/dux ...
UVAlive4287 Proving Equivalences（scc）
题目链接:http://acm.hust.edu.cn/vjudge/problem/viewProblem.action?id=10294 [思路] 强连通分量. 求出bcc后,缩点形成DAG,设D ...
高性能web系统的架构和系统优化
07年毕业一直都在软件公司,14年来到一个互联网公司,给我的感受,区别主要在于: 软件公司需求相对稳定,能够按照计划按部就班的去实施,互联网公司需求相对来说不稳定,上线比较着急,大部分都是小迭代更新, ...
puppet常用调试命令
yum快速部署puppet测试环境(C/S端) rpm -ivh http://yum.puppetlabs.com/puppetlabs-release-el-7.noarch.rpm yum r ...
CSS里的 no-repeat 是什么意思
CSS里的 no-repeat是针对背景图片来说的.当你设置了no-repeat这个属性后,你的背景图片将不会被重复,再换一种说法,你在网站上所看到的背景图片就是你所添加的图片, 不会出现平铺或者重复 ...

java学习——集合框架(Collection,List,Set)

java学习——集合框架(Collection,List,Set)的更多相关文章

随机推荐

热门专题