JAVA基础学习day14--集合一

一、集合的出现

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

posted @ 2015-09-23 11:39 森林森阅读(527) 评论(0) 编辑收藏举报

刷新页面返回顶部

森林森

一份耕耘，一份收获

JAVA基础学习day14--集合一

pollFirst或者pollLast

三、Set

公告