Java语言基础常用对象API（二）集合框架

基本数据类型对象包装类

为了方便操作基本数据类型值，将其封装成了对象，在对象中定义了属性和行为，丰富了
该对象的操作。用于描述该对象的类就称为基本数据类型的对象包装类。

基本类型（对应对象）：byte-Byte、short-Short、int-Integer、long-Long、
float-Float、double-Double、char-Character、boolean-Boolean。

该包装对象主要用于基本类型字符串之间的转换
例：static int parseInt(String s) //将字符串参数作为有符号的十进制整数进行解析。

基本类型---->字符串
    1.基本数据类型+“”；
    2.用String类中的静态方法valueOf(基本数据类型)；
    3.用Integer的静态方法valueOf();
字符串---->基本类型
    1.使用包装类中的方法 parseInt()、parseLong()、parseDouble()、
            Boolean.parseBoolean("booleanstring")等；
            只有Character没有parse方法；
    2.如果字符串被Integer进行了对象的封装，可以使用另一个非静态的方法
            intValue()；

    整数具备不同的进制体现：
    十进制---->其他进制
        十进制---->二进制        Integer.toBinaryString();
        十进制---->八进制        Integer.toOctalString();
        十进制---->十六进制    Integer.toHexString();
        十进制---->任意进制    Integer.toString(int i,int radix);//返回用第二个参数指定基   
                                                                        数表示的第一个参数的字符串表示形式

    其他进制---->十进制
    parseInt(String s, int radix);//使用第二个参数指定的基数，将字符串参数解析为有
    符号的整数。

JDK1.5自动装箱拆箱
Integer i=4;//i=new Integer(4);自动装箱，简化书写
i=i+6;//i=new Integer(i.intValue()+6);自动拆箱，如果i=null，则出现异常

Integer a=new Integer(127);
Integer b=new Integer(127);
System.out.println(a==b);//false
System.out.println(a.equals(b));//true
       
Integer x=127;//jdk1.5以后，自动装箱，如果装箱的是一个字节，
Integer y=127;//那么该数据会被共享，不会重新开辟控件
System.out.println(x==y);//true,若x、y>127，则false
System.out.println(x.equals(y));//true

基本数据类型对象包装类练习：

package cn.itcast.p2.wrapper.demo;

import java.util.Arrays;

/*
 * 对一个字符串中的数值进行从小到大的排序
 * "20 78 9 -7 88 36 29"
 * 思路：
 * 1.排序
 * 2.如何获取到字符串中需要排序的数值？
 *     这个字符串中都是使用空格来对数值进行分割的，所以
 *     就想到用字符串对象的切割方法将大串变成多个小串；
 * 3.数值最终变成了小字符串，需要转换为int数值；
 *     字符串-->基本类型，使用包装类
 */
public class WrapperTest {
    private static final String SPACE_SEPARATOR=" ";
    /**
     * @param args
     */
    public static void main(String[] args) {
        String numStr = "20 78 9 -7 88 36 29";
        System.out.println(numStr);
        numStr = sortStringNumber(numStr);
        System.out.println(numStr);

    }

    public static String sortStringNumber(String numStr) {
        // 1.将字符串变成数组
        String[] str_arr = stringToArray(numStr);
        // 2.将字符串数组变成int数组
        int[] num_arr = toIntArray(str_arr);
        // 3.对int数组排序
        mySortArray(num_arr);
        // 4.将排序后的int数组变成字符串
        String temp = arrayToString(num_arr);
        return temp;
    }

    public static String arrayToString(int[] num_arr) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < num_arr.length; i++) {
            if (i != num_arr.length - 1)
                sb.append(num_arr[i] + SPACE_SEPARATOR);
            else
                sb.append(num_arr[i]);
        }
        return sb.toString();
    }

    public static void mySortArray(int[] num_arr) {
        Arrays.sort(num_arr);
    }

    public static int[] toIntArray(String[] str_arr) {
        int[] arr = new int[str_arr.length];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = Integer.parseInt(str_arr[i]);
        }
        return arr;
    }

    public static String[] stringToArray(String numStr) {
        String[] str_arr = numStr.split(SPACE_SEPARATOR);
        return str_arr;
    }

}

集合框架
集合类
StringBuffer、StringBuilder最终必须转成字符串才可以使用。
集合类的由来
    对象用于封装特有数据，对象多了需要存储，如果对象的个数不确定，就使用集合容器进行存储。
特点：
    1.用于存储对象的容器；
    2.集合的长度是可变的；
    3.集合中不可以存储基本数据类型值；

集合容器因为内部的数据结构不同，有多种具体容器。不断向上抽取，就形成了集合框架。框架的顶层是Collection接口。
Collection的常见功能：
1.添加
    boolean add(Object e) //确保此 collection 包含指定的元素（可选操作）。
    boolean addAll(Collection coll)//将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。
2.删除
    boolean remove(Object o)//从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。
    boolean removeAll(Collection coll)//移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。
    void clear()//移除此 collection 中的所有元素（可选操作）。
3.判断
    boolean contains(Object o)//如果此 collection 包含指定的元素，则返回 true。
    boolean containsAll(Collection coll)//如果此 collection 包含指定 collection 中的所有元素，则返回 true。
    boolean isEmpty()//如果此 collection 不包含元素，则返回 true。
4.获取
    int size();//返回此 collection 中的元素数。
    Iterator<E> iterator();//返回在此 collection 的元素上进行迭代的迭代器。
    该对象必须依赖于具体的容器，因为每一个容器的数据结构都不同。所以该迭代器对象是在容器内部进行实现的。
    对于使用容器者而言，具体的实现不重要，只要通过容器获取到该实现的迭代器对象即可。也就是iterator方法。
    Iterator接口就是对所有的Collection容器进行元素取出的公共接口。
5.其他
    boolean retainAll(Collection coll)//仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。 取交集
    Object[] toArray();//返回包含此 collection 中所有元素的数组。

迭代器使用示例：

package cn.itcast.p3.collection.demo;

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

public class IteratorDemo {

    /**
     * @param args
     */
    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());
        }

    }
}

常用的子接口
List和Set

List特点
public interface List<E>extends Collection<E>
1.有序的 collection（也称为序列），存取顺序一致；
2.元素都有索引；
3.存储的元素允许重复；
Set特点
1.元素不能重复；
2.无序（可能有序）；

List特有的常见方法：
有一个共性特点：都可以操作角标。
1.添加
    void add(int index, E element) 在列表的指定位置插入指定元素（可选操作）。
    boolean addAll(int index, Collection c) 将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。
2.删除
    Object remove(int index) 移除列表中指定位置的元素（可选操作）。
3.修改
    Object set(int index, Object element) 用指定元素替换列表中指定位置的元素（可选操作）。
4.获取
    Object get(int index) 返回列表中指定位置的元素。
    ※List特有的取出方式。

    int indexOf(Object o) 返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
    int lastIndexOf(Object o) 返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。
    List  subList(int fromIndex, int toIndex) 返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图
List集合可以完成对元素的增删查改。
List使用示例：

package cn.itcast.p4.collection.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);
        list.add("abc1");
        list.add("abc2");
        list.add("abc3");

        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);

        /*
        // Iterator it = list.iterator();
        while (it.hasNext()) {
         Object obj = it.next();// java.util.ConcurrentModificationException
         // 迭代器迭代过程中，集合产生了操作。解决：使用迭代方法 //在迭代过程中，不要使用集合操作元素，容易出现异常
         // 可以使用Iterator接口的子接口ListIterator来完成在迭代中对元素进行更多的操作
         if (obj.equals("abc2")) {
         list.add("abc9");
         } else
         System.out.println("next:" + obj);
         }
         System.out.println(list);
            */
    }

List：
    |--Vector    内部是数组数据结构，是同步的（效率低）。增删、查询都很慢。
    |--ArrayList    内阻是数组数据结构，是不同步的（效率高）。替代了Vector。查询速度快。
    |--LinkedList    内部是链表数据结构，是不同步的。增删速度快。

Vector:
public interface Enumeration<E>
此接口的功能与 Iterator 接口的功能是重复的。此外，Iterator 接口添加了一个可选的移除操作，并使用较短的方法名。新的实现应该优先考虑使用 Iterator 接口而不是 Enumeration 接口。

LinkedList：
void addFirst(E e) 将指定元素插入此列表的开头。
void addLast(E e)  将指定元素添加到此列表的结尾。
boolean offerFirst(E e) 在此列表的开头插入指定的元素。
boolean offerLast(E e) 在此列表末尾插入指定的元素。

※
E removeFirst() 移除并返回此列表的第一个元素。 如果没有元素则抛出异常（NoSuchElementException）。
E removeLast() 移除并返回此列表的最后一个元素。 如果没有元素则抛出异常（NoSuchElementException）。
E pollFirst() 获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
E pollLast() 获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。

E getFirst() 获取但不移除此列表的第一个元素。 如果没有元素则抛出异常（NoSuchElementException）。
E getLast() 获取但不移除此列表的最后一个元素。如果没有元素则抛出异常（NoSuchElementException）。
E peekFirst() 获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。
E peekLast() 获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。

LinkedList练习示例：

package cn.itcast.p2.linkedlist.test;


/*
 * 请使用LinkedList来模拟一个堆栈或者队列数据结构
 * 堆栈：先进后出（FILO）
 * 
 * 队列：先进先出（FIFO）
 * 
 * 描述这样一个容器，给使用者提供一个容器对象，完成这两种结构。
 */


public class LinkdeTest {

    /**
     * @param args
     */
    public static void main(String[] args) {
        DuiLie dl=new DuiLie();
        dl.myAdd("abc1");
        dl.myAdd("abc2");
        dl.myAdd("abc3");
        dl.myAdd("abc4");
        
        while(!dl.isNull()){
            System.out.println(dl.myGet());
        }
    }

}
package cn.itcast.p2.linkedlist.test;

import java.util.LinkedList;

public class DuiLie{
    private LinkedList link;
    DuiLie(){
        link=new LinkedList();
    }
    /**
     * 队列的添加元素的方法
     * @param obj
     */
    public void myAdd(Object obj){
        link.addLast(obj);
    }
    public Object myGet(){
        return link.removeFirst();
    }
    public boolean isNull(){
        return link.isEmpty();
    }
}

ArrayList练习示例：

package cn.itcast.p.bean;

public class Person {

    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;
    }
    
}
package cn.itcast.p3.arraylist.test;

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

import cn.itcast.p.bean.Person;

public class ArrayListTest {

    /**
     * @param args
     */
    public static void main(String[] args) {
        ArrayList al = new ArrayList();
        al.add(new Person("lisi1", 21));
        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()) {
            // System.out.println(((Person) it.next()).getName()+"::"+((Person)
            // it.next()).getAge());//会出现错误
            Person p = (Person) it.next();
            System.out.println(p.getName() + "::" + p.getAge());
        }
    }
}

ArrayList练习：

package cn.itcast.p3.arraylist.test;

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

import cn.itcast.p.bean.Person;

/*
 * 定义功能去除ArrayList中的重复元素
 */
public class ArrayListTest2 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // singleDemo();

        ArrayList al = new ArrayList();
        al.add(new Person("lisi1", 21));
        al.add(new Person("lisi2", 22));
        al.add(new Person("lisi3", 23));
        al.add(new Person("lisi4", 24));
        al.add(new Person("lisi2", 22));
        al.add(new Person("lisi3", 23));
        System.out.println(al);

        al = getSingleElement(al);
        System.out.println(al);
    }

    public static ArrayList getSingleElement_2(ArrayList al) {
        // 1.定义一个临时容器
        ArrayList temp = new ArrayList();

        // 2.迭代al集合
        Iterator it = al.iterator();
        while (it.hasNext()) {
            Object obj = it.next();
            // 3.判断被迭代到的元素是否存在于临时容器中
            if (!(temp.contains(obj))) {
                temp.add(obj);
            }
        }
        return temp;
    }

    /**
     * 
     */
    private static void singleDemo() {
        ArrayList al = new ArrayList();
        al.add("abc1");
        al.add("abc2");
        al.add("abc2");
        al.add("abc1");
        al.add("abc");
        System.out.println(al);

        al = getSingleElement(al);
        System.out.println(al);
    }

    public static ArrayList getSingleElement(ArrayList al) {
        // 1.定义一个临时容器
        ArrayList temp = new ArrayList();

        // 2.迭代al集合
        Iterator it = al.iterator();
        while (it.hasNext()) {
            Object obj = it.next();
            // 3.判断被迭代到的元素是否存在于临时容器中
            if (!(temp.contains(obj))) {
                temp.add(obj);
            }
        }
        return temp;
    }

}
package cn.itcast.p.bean;

public class Person {

    private String name;
    private int age;

    public Person() {
        super();

    }

    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    @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;
    }

}

判断元素是否重复：
ArrayList使用equals，HashSet使用hashCode和equals

Set：元素不能重复，是无序的。
    Set接口中的方法与Collection一致。
    |--HashSet        内部数据结构是哈希表，是不同步的。
    |--TreeSet       

哈希表确定元素是否相同
1.判断的是两个元素的哈希值是否相同；
        如果相同，再判断两个对象的内容是否相同。
2.判断哈希值相同，其实判断的是对象的hashCode方法；
        判断内容相同，用的是equals方法。
注意：如果哈希值不同，不需要判断equals方法。

HashSet示例：

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 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        HashSet hs=new HashSet();
        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));//对象地址不同，系统认为是不同的对象（Object的equals比较地址）
                                        //需重写hashCode和equals
        
        /*
         * HashSet集合数据结构是哈希表，所以存储元素的时候，
         * 使用的元素的hashCode方法来确定位置，如果位置相同，再通过元素的equals来确定是否相同
         * 
         */
        Iterator it=hs.iterator();
        while(it.hasNext()){
            Person p=(Person)it.next();
            System.out.println(p.getName()+"..."+p.getAge());
        }
    }

}
package cn.itcast.p.bean;

public class Person {

    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*39;//age*39 保证哈希值的唯一，避免使用equals进行比较
    }

    @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;
    }

}

LinkedHashSet：具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。
        HashSet hs=new LinkedHashSet();

TreeSet：
基于 TreeMap 的 NavigableSet 实现。
可以对Set集合中的元素，使用自然顺序对元素进行排序。
判断元素唯一性的方式，就是根据比较方法CompareTo的返回结果是否是0。是0，则认为是相同元素，不存储。
TreeSet集合对元素进行排序的方式一：
让元素自身具备比较功能，元素需要实现Comparable接口，覆盖CompareTo方法；

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

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) {
//        demo1();
        
        /*
         * 以Preson对象的年龄，进行从小到大的排序
         */
        TreeSet ts=new TreeSet(new ComparatorByName());//不使用默认比较方式，则定义比较器
        ts.add(new Person("zhangsan",29));
        ts.add(new Person("wangwu",23));
        ts.add(new Person("lisi",21));
        ts.add(new Person("zhouqi",29));
        ts.add(new Person("zhaoliu",25));
        
        Iterator it=ts.iterator();
        while(it.hasNext()){
            Person p=(Person)it.next();
            System.out.println(p.getName()+":"+p.getAge());
        }
    }
}
package cn.itcast.p5.treeset.demo;

import java.util.Comparator;

import cn.itcast.p.bean.Person;

/**
 * 创建以Person对象年龄进行从小到大的排序
 * @author chenchong
 *
 */
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;
    }

}

TreeSet练习：

package cn.itcast.p5.treeset.test;

import java.util.Iterator;
import java.util.TreeSet;

import cn.itcast.p5.comparator.ComparatorByLength;
/*
 * 对字符串进行按长度排序
 */
public class TreeSetTest {

    /**
     * @param args
     */
    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());
        }
    }

}
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;//在长度相同时，按元素排序
    }

    
}