码迷，mamicode.com
首页 > 编程语言 > 详细

JAVA基础学习day13--集合一

时间：2015-09-23 11:48:03      阅读：219      评论：0      收藏：0      [点我收藏+]

标签：

一、集合的出现

1.1、集合简述

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

1.2、数组和集合都是容器

数组也存对象，存储同一种类型，但数组是固定长度的，集合长度是可变。

数组中可以存储基本数据类型，集合只能存储对象

1.3、集合特点

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

1.4、结构

技术分享

 

二、集合共性方法

2.1、Collection接口顶级

Collection 层次结构 中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。JDK 不提供此接口的任何直接 实现：它提供更具体的子接口（如 Set 和 List）实现。此接口通常用来传递 collection，并在需要最大普遍性的地方操作这些 collection。

2.2、共性方法

 

方法摘要
boolean add(E e)
确保此 collection 包含指定的元素（可选操作）。
boolean addAll(Collection<? extends E> c)
将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。
void clear()
移除此 collection 中的所有元素（可选操作）。
boolean contains(Object o)
如果此 collection 包含指定的元素，则返回 true。
boolean containsAll(Collection<?> c)
如果此 collection 包含指定 collection 中的所有元素，则返回 true。
boolean equals(Object o)
比较此 collection 与指定对象是否相等。
int hashCode()
返回此 collection 的哈希码值。
boolean isEmpty()
如果此 collection 不包含元素，则返回 true。
Iterator<E> iterator()
返回在此 collection 的元素上进行迭代的迭代器。
boolean remove(Object o)
从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。
boolean removeAll(Collection<?> c)
移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。
boolean retainAll(Collection<?> c)
仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。
int size()
返回此 collection 中的元素数。
Object[] toArray()
返回包含此 collection 中所有元素的数组。
<T> T[]
toArray(T[] a)
返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。

 2.3、ArrayList示例

 

import java.util.*;

class CollectionDemo {
    public static void main(String[] args) {
        // 声明2个集合容器，并添加元素
        List<String> ar1 = new ArrayList<String>();
        ar1.add("a");
        ar1.add("b");
        ar1.add("c");
        ar1.add("d");
        ar1.add("e");
        // 遍历
        sop("ar1遍历:");
        getIterator(ar1);

        List<String> ar2 = new ArrayList<String>();
        ar2.add("a");
        ar2.add("b");
        ar2.add("f");
        ar2.add("q");
        ar2.add("w");
        // 增强for循环遍历
        sop("ar2遍历:");
        getFor(ar2);

        // 求集合的长度
        sop("ar1的长度:" + ar1.size());
        sop("ar2的长度:" + ar2.size());
        // 比较判断
        sop("ar1中有字符a吗 : " + ar1.contains("a"));
        // 整个集合比较
        sop("ar1中有字符ar2吗 : " + ar1.containsAll(ar2));
        // 求交集
        ar1.retainAll(ar2);
        sop("求交集");
        getFor(ar1);
        // addALL
        ar1.addAll(ar2);
        // 增强for循环遍历
        sop("添加ar2后的ar1:");
        getFor(ar1);

        // 删除
        ar1.remove("c");
        sop("ar1删除指定c后");
        getFor(ar1);
        sop("ar1删除指定集合");
        ar1.removeAll(ar2);
        getFor(ar1);
        sop("ar1是空吗？" + ar1.isEmpty());
        // 清空
        ar1.clear();
        sop(ar1.size());
    }

    // iterator遍历集合
    public static void getIterator(List<String> list) {
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String str = iterator.next();
            sop(str);
        }
    }

    // forEach遍历
    public static void getFor(List<String> list) {
        for (String str : list) {
            sop(str);
        }
    }

    // 打印
    public static void sop(Object obj) {
        System.out.println(obj);
    }
}

 

结果：

ar1遍历:
a
b
c
d
e
ar2遍历:
a
b
f
q
w
ar1的长度:5
ar2的长度:5
ar1中有字符a吗 : true
ar1中有字符ar2吗 : false
求交集
a
b
添加ar2后的ar1:
a
b
a
b
f
q
w
ar1删除指定c后
a
b
a
b
f
q
w
ar1删除指定集合
ar1是空吗？true
0

2.4、Iterator

 

方法摘要
boolean hasNext()
如果仍有元素可以迭代，则返回 true。
E next()
返回迭代的下一个元素。
void remove()
从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）。

 2.5、ArrayList

 

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * List:元素是有序的，元素可以重复，该集合体系有索引
 * Set:元素是无序，元素不可以重复
 * List:
 *         特有方法：可以操作索引的方法都 是特有
 *     add(index ,element)
 * addAll(index,Collection);
 * remove (index)
 * set(index,element)
 * get(index);
 * subList(from,to)
 * listIterator()
 * 
 * 
 */
public class ListDemo {

    public static void main(String[] args) {
        //add();
        //remove();
        //set();
        //getIndex();
        indexSub();
    }
    
    //indexOf和subList
    public static void indexSub(){
        List<String> list=new ArrayList<String>();
        //添加元素
        list.add("java01");
        list.add("java02");
        list.add("java03");
        list.add("java04");
        list.set(2,"hello");
        sop(list.indexOf("java04"));//3
        sop(list.indexOf("java09"));//-1
        sop(list.lastIndexOf("hello"));//2
        List<String> subList=list.subList(1, 3);
        sop(subList);//hello,java03
    }
    
    //遍历
    public static void getIndex(){
        List<String> list=new ArrayList<String>();
        //添加元素
        list.add("java01");
        list.add("java02");
        list.add("java03");
        list.add("java04");
        list.set(2,"hello");
        //循环遍历，通过索引的方式遍历和数组一样
        for(int x=0;x<list.size();x++){
            sop("list["+x+"]="+list.get(x));
        }
        
    }
    
    //修改
        public static void set(){
            List<String> list=new ArrayList<String>();
            //添加元素
            list.add("java01");
            list.add("java02");
            list.add("java03");
            list.add("java04");
            list.set(2,"hello");
            //遍历
            get(list);
        }
    //删除元素
    public static void remove(){
        List<String> list=new ArrayList<String>();
        //添加元素
        list.add("java01");
        list.add("java02");
        list.add("java03");
        list.add("java04");
        list.remove(2);
        //遍历
        get(list);
    }
    
    //添加元素
    public static void add(){
        List<String> list=new ArrayList<String>();
        //添加元素
        list.add("java01");
        list.add("java02");
        list.add("java03");
        //遍历
        get(list);
        //在指定位置添加
        list.add(1,"java09");
        //遍历
        System.out.println("========在指定位置添加后==========");
        get(list);
    }
    //遍历
    public static void get(List<String> list){
        for(Iterator<String> it=list.iterator();it.hasNext();){
            sop(it.next());
        }
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
    
}

2.6、列表迭代器 listIterator

iterator，只能做判断、删除、取出，不能做其它操作

listIterator

public ListIterator<E> listIterator(int index)

返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始。指定的索引表示 next 的初始调用所返回的第一个元素。previous 方法的初始调用将返回索引比指定索引少 1 的元素。

此实现返回 ListIterator 接口的直接实现，扩展了由 iterator() 方法返回的 Iterator 接口的实现。ListIterator 实现依赖于底层实现列表的 get(int)、set(int, E)、add(int, E) 和 remove(int) 方法。

注意，除非重写列表的 remove(int)、set(int, E) 和 add(int, E) 方法，否则此实现返回的列表迭代器将抛出 UnsupportedOperationException 来响应其 remove、set 和 add 方法。

根据 (protected) modCount 字段规范中的描述，在面临并发修改时，可以使此实现抛出运行时异常。 

 

方法摘要
void add(E e)
将指定的元素插入列表（可选操作）。
boolean hasNext()
以正向遍历列表时，如果列表迭代器有多个元素，则返回 true（换句话说，如果 next 返回一个元素而不是抛出异常，则返回 true）。
boolean hasPrevious()
如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。
E next()
返回列表中的下一个元素。
int nextIndex()
返回对 next 的后续调用所返回元素的索引。
E previous()
返回列表中的前一个元素。
int previousIndex()
返回对 previous 的后续调用所返回元素的索引。
void remove()
从列表中移除由 next 或 previous 返回的最后一个元素（可选操作）。
void set(E e)
用指定元素替换 next 或 previous 返回的最后一个元素（可选操作）。

 

 

package com.pb.list.demo1;

import java.util.ArrayList;
import java.util.List;
import java.util.*;

public class ListIteratorDemo {

    public static void main(String[] args) {
        List<String> list=new ArrayList<String>();
        //添加元素
        list.add("java01");
        list.add("java02");
        list.add("java03");
        list.add("java04");
        list.add("java05");
        //获取listIterator迭代器
        ListIterator<String> listIterator=list.listIterator();
        while(listIterator.hasNext()){
            if(listIterator.next().equals("java02")){//判断
                //修改
                listIterator.set("java007");
                //添加
                listIterator.add("hello");
            }
            
        }
        sop(list);
        //倒序输出遍历
        while(listIterator.hasPrevious()){
            sop(listIterator.previous());
        }
        
    }
    public static void sop(Object obj){
        System.out.println(obj);
            
    }

}

 

2.7、Vector

 

package com.pb.list.demo1;

import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.Vector;

public class VectorDemo {

    public static void main(String[] args) {
        Vector<String> vector=new Vector<String>();
        //添加元素
        vector.add("java01");
        vector.add("java02");
        vector.add("java03");
        vector.add("java04");
        vector.add("java05");
        
        //获取枚举
        Enumeration<String> en=vector.elements();
        while(en.hasMoreElements()){
            System.out.println(en.nextElement());
        }

    }

}

 

 

2.8、LinkedList

 

package com.pb.list.demo1;

import java.util.LinkedList;

/**
 * LinkedList特有方法： 
 * 添加元素到第一个索引位置 addFirst();
* 添加元素到最后一个索引位置 addLast(); 
* 获取索引为0的元素 getFirst(); 
 * 获取索引最后的元素 getLast(); 
 * 删除索引为0的元素 removeFirst();
 *  删除索引为size()-1的元素 * removeLast();
 */

public class LinkedListDemo {

    public static void main(String[] args) {
        // 声明一个链表集合
        LinkedList<String> list = new LinkedList<String>();
        // 添加到第一个元素
        list.addFirst("1");
        list.add("2");
        list.add("3");
        sop(list);// 3,2,1
        // 将元素添加到最后
        list.addLast("6");
        list.addLast("5");
        list.addLast("4");// 3,2,1,6,5,4
        sop(list);// 获取第一个元素
        sop(list.getFirst());//3
        // 获取最后一个元素
        sop(list.getLast());// 4
        // 删除第一个元素
        sop(list.removeFirst());
        // 删除最后一个
        sop(list.removeLast());
        sop(list);// 2,1,6,5

        /*
         * 获取集合全部元素，不使用迭代器
         */
        while (!list.isEmpty()) {
            list.removeFirst();// list.removeLast();
        }

    }

    public static void sop(Object obj) {
        System.out.println(obj);
    }
}

removeFirst或者removeLast

public E removeFirst()

移除并返回此列表的第一个元素。

 

指定者：
接口 Deque<E> 中的 removeFirst

返回：

此列表的第一个元素

抛出：

NoSuchElementException - 如果此列表为空

JDK 1.6之后提供了新的方法

pollFirst或者pollLast

public E pollFirst()
获取并移除此列表的第一个元素；如果此列表为空，则返回 null。

 

指定者：
接口 Deque<E> 中的 pollFirst
返回：
此列表的第一个元素；如果此列表为空，则返回 null
从以下版本开始：
1.6 

示例

package com.pb.list.demo1;

import java.util.LinkedList;
/**
 * JDK 1.6提供了新的方法
 * offerFirst()，添加元素到第个
 * offerLast(),添加元素到最后一位
 * 
 * peekFirst()获取第一个元素
 * peekLast()获取最后一个元素
 * 
 * pollFirst()删除第一个元素
 * pollLast()删除最后一个元素
 *
 */
public class LinkedListDemo1 {
    
    public static void main(String[] args) {

    // 声明一个链表集合
            LinkedList<String> list = new LinkedList<String>();
            // 添加到第一个元素
            list.offerFirst("1");
            list.offerFirst("2");
            list.offerFirst("3");
            sop(list);// 3,21
            // 将元素添加到最后
            list.offerLast("6");
            list.offerLast("5");
            list.offerLast("4");// 3,2,1,6,5,4
            sop(list);
            // 获取第一个元素
            sop(list.peekFirst());// 3
            // 获取最后一个元素
            sop(list.peekLast());// 4
            // 删除第一个元素
            sop(list.pollFirst());
            // 删除最后一个
            sop(list.pollLast());
            sop(list);// 2,1,6,5

            /*
             * 获取集合全部元素，不使用迭代器
             */
            while (!list.isEmpty()) {
                list.pollFirst();// list.pollLast()
            }

        }

        public static void sop(Object obj) {
            System.out.println(obj);
        }

}

 

示例：

package com.pb.list.demo1;

import java.util.LinkedList;

/**
 * 使用LinkedList模拟一个堆栈或者队列数据结构
 * 堆栈：先进后出
 * 队列：先进先出 
 * 
 *
 */
public class LinkedListDemo2 {

    public static void main(String[] args) {
        Que q=new Que();
        q.myAdd("java01");
        q.myAdd("java02");
        q.myAdd("java03");
        q.myAdd("java04");
        q.myAdd("java05");
        while(!q.isNUll()){
            //输出
            System.out.println(q.myGet());
        }
    }

}
class Que{
    private LinkedList list=null;
    public Que(){
        list=new LinkedList();
        
    }
    
    //判断是不是NULL
    public boolean isNUll(){
        return list.isEmpty();
    }
    //添加
    public void myAdd(Object obj){
        list.offerFirst(obj);
    }
    //删除
    public Object myGet(){
        return list.pollLast(); //先出
        // return list.pollFirst();
    }
}

示例，去除list的重复元素

package com.pb.list.demo1;

import java.util.ArrayList;
import java.util.Iterator;

/**
 * 去除ArrayList中的重复元素
 * @author Administrator
 *
 */
public class ArrayListDemo1 {

    public static void main(String[] args) {
        ArrayList list=new ArrayList();
        list.add("java01");
        list.add("java01");
        list.add("java02");
        list.add("java02");
        list.add("java03");
        list.add("java03");
        list.add("java019");
        System.out.println(getSingle(list));

    }
    public static ArrayList getSingle(ArrayList list){
        ArrayList tempList=new ArrayList();
        for(Iterator it=list.iterator();it.hasNext();){
            Object obj=it.next();
            if(!tempList.contains(obj)){
                tempList.add(obj);
            }
        }
        
        return tempList;
    }

}

 

 示例，去除list的重复对象

package com.pb.list.demo1;

public class Person {
    private String name;
    private int age;
    
    
    
    
    //重写equals
    @Override
    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 Person() {
        super();
        // TODO Auto-generated constructor stub
    }
    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 void show(){
        System.out.println(this.name+"........"+this.age);
    }
}

 

 

 

package com.pb.list.demo1;

import java.util.ArrayList;
import java.util.Iterator;

/**
 * 去除ArrayList中的重复元素
 * @author Administrator
 *
 */
public class ArrayListDemo1 {

    public static void main(String[] args) {
        Person p1=new Person("张三",19);
        Person p2=new Person("张三",19);
        Person p3=new Person("李四",23);
        Person p4=new Person("李四",23);
        Person p5=new Person("王五",33);
        Person p6=new Person("王五",23);
        Person p7=new Person("赵六",18);
        
        ArrayList<Person> list=new ArrayList<Person>();
        list.add(p1);
        list.add(p2);
        list.add(p3);
        list.add(p4);
        list.add(p5);
        list.add(p6);
        
        //遍历去掉重复后的
        for(Person p:getSingle(list)){
            p.show();
        }
        

    }
    public static ArrayList<Person> getSingle(ArrayList<Person> list){
        ArrayList<Person> tempList=new ArrayList<Person>();
        for(Iterator<Person> it=list.iterator();it.hasNext();){
            Person p=it.next();
            if(!tempList.contains(p)){ //contains也是调用对象equals方法
                tempList.add(p);
            }
            
        }
        
        return tempList;
    }

}

 

 

2.9、三种集合区别

ArrayList：底层的数据结构使用是数组结构,遍历快，增、删、改，慢,线程不同步

LinkedList：底层的数据结构使用链表数据结构，遍历慢，增、删、改，快，

Vector:底层的数据结构使用是数组结构,线程同步的，被ArrayList替代了。

 

 

三、Set

3.1、List和Set区别

 List:元素是有序的，元素可以重复，该集合体系有索引
Set:元素是无序，元素不可以重复

一个不包含重复元素的 collection。更确切地讲，set 不包含满足 e1.equals(e2) 的元素对 e1 和 e2，并且最多包含一个 null 元素。

3.2、常见子类

HashSet--哈希表,TreeSet

3.3、功能方法

Set的方法和Collection一样，使用方式也一样

 

 

package com.pb.list.demo1;

public class Person {
    private String name;
    private int age;
    
    
    
    //重写hashCode
    @Override
    public int hashCode() {
        System.out.println("========hashCode");
        return name.hashCode()+age*39;
    }
    //重写equals
    @Override
    public boolean equals(Object obj) {
        if(!(obj instanceof Person)){
            return false;
        }
        Person p=(Person)obj;
        System.out.println(p.name+"========equals"+p.age);
        return this.name.equals(p.name)&&this.age==p.age;
    }
    public Person() {
        super();
        // TODO Auto-generated constructor stub
    }
    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 void show(){
        System.out.println(this.name+"........"+this.age);
    }
}

 

package com.pb.list.demo1;

import java.util.HashSet;
import java.util.Iterator;

public class Demo1 {

    public static void main(String[] args) {
        Person p1=new Person("张三",19);
        Person p2=new Person("李四",20);
        Person p3=new Person("张三",19);
        Person p4=new Person("李四",20);
        Person p5=new Person("五一",19);
        Person p6=new Person("五一",19);
        HashSet<Person> set=new HashSet<Person>();
        set.add(p6);
        set.add(p5);
        set.add(p4);
        set.add(p3);
        set.add(p2);
        set.add(p1);
        Iterator<Person> iterator=set.iterator();
        while(iterator.hasNext()){
            Person p=iterator.next();
            p.show();
        }

        
    }

}
========hashCode
========hashCode
五一========equals19
========hashCode
========hashCode
========hashCode
李四========equals20
========hashCode
张三========equals19
李四........20
张三........19
五一........19

ArrayList:判断元素是否存或者删除依赖的方法equals()方法

Set:判断元素是否存或者删除，依赖的方法hashCode()和equals()方法,先判断hashCode如果有再判断equals

 

JAVA基础学习day13--集合一

标签：

原文地址：http://www.cnblogs.com/liunanjava/p/4827368.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！