黑马程序员_Java学习日记第五天--集合

------- android培训、 java培训、期待与您交流！ ----------

List:特有方法。凡是可以操作角标的方法都是该体系特有的方法。

增

add(index,element);

addAll(index,Collection);

删

remove(index);

改

set(index,element)

查

get(index)

sublist(from,to)

listIterator();

 

List集合特有的迭代器ListIterator是Iterator的子接口。

在迭代时，不可以通过集合的方法访问集合中的内容，否则会发生ConcurrentModificationException异常

所以在迭代时只能用迭代器的方法操作元素，可是Iterator的方法是有限的，只能对元素进行判断、取出、删除的操作

如果想要其他的操作，如添加、修改等，就必须通过list的子接口ListIterator

该接口只能通过list集合的ListIterator方法获取

ListIterator(在遍历过程中可以进行增删改查)

 

List集合方法使用举例：

import java.util.*;

 

 

publicclassTestDemo {

    publicstaticvoid method()

    {

        ArrayListal=new ArrayList();

        al.add("s1");

        al.add("s2");

        al.add("s3");

        al.add(0,"s2");//在指定位置添加元素，相当于插入

        //al.remove(1);

        al.set(1,"s7");//改指定位置的值

        ArrayListnewal=new ArrayList();

        newal.add("n1");

        al.addAll(newal);//添加集合

        System.out.println(al.get(2));

        //通过for循环访问list集合元素

        for(int x=0;x<al.size();x++)

        {

            System.out.println("al["+x+"]="+al.get(x));

        }

        //Iterator迭代器

        Iteratorit=al.iterator();

        while(it.hasNext())

        {

            System.out.println(it.next());

        }

        //通过indexof获取对象的位置

        System.out.println(al.indexOf("s2"));

        Listsub=al.subList(1, 2); //包括头不包括尾

        System.out.println("sub="+sub);

    }

    publicstaticvoid main(String[] args) {

        method();

        ArrayListal=new ArrayList();

        al.add("s1");

        al.add("s2");

        al.add("s3");

       

/*

        Iteratorit=al.iterator();

        while(it.hasNext())

        {

            al.add("s4");//不能在迭代器中使用集合的添加方法，会导致发生ConcurrentModificationException并发修改异常

            System.out.println(it.next());

        }

*/

        //在迭代过程中，添加或删除元素

        ListIteratorli=al.listIterator();

        while(li.hasNext())

        {

            Objectobj=li.next();

            if(obj.equals("s1"))

                {li.add("S10");

                //li.set("S10");

                }

        }  

        System.out.println(al);

        //逆向遍历

        while(li.hasPrevious())

        {System.out.print(li.previous()+" ");}

        }

    }

运行结果是：s2

al[0]=s2

al[1]=s7

al[2]=s2

al[3]=s3

al[4]=n1

s2

s7

s2

s3

n1

0

sub=[s7]

[s1, S10, s2, s3]

s3 s2 S10 s1

 

 

Linkedlist特有方法：

增

addFirst();

addLast();

查

getFirst();

getLast();

获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException

 

删

removeFirst();

removeLast();

获取元素，但是元素被删除，如果集合中没有元素，会出现NoSuchElementException

 

 

1.6出现的新方法

offerFirst();

offerLast();

peekFirst();

peekLast();

获取元素，但不删除元素。如果集合中没有元素，会返回null。

 

pollFirst();

pollLast();

获取元素，但是元素被删除，如果集合中没有元素，会返回null。

 

堆栈：先进后出

队列：先进先出

 

模拟队列代码：

import java.util.*;

 

 

publicclassDuiLieDemo {

   

   

    publicstaticvoid main(String[] args)

    {

        DuiLiedl=newDuiLie();

        dl.MyAdd("zh1");

        dl.MyAdd("zh2");

        dl.MyAdd("zh3");

        while(!dl.isNull())

        {

            System.out.println(dl.MyGet());

        }

    }

}

class DuiLie

{

    private LinkedListlink;

    DuiLie()

    {

        link=new LinkedList();

    }

    publicvoid MyAdd(Object obj)

    {

        link.addFirst(obj);

    }

    public Object MyGet()

    {

        returnlink.removeLast();

    }

    publicboolean isNull()

    {

        returnlink.isEmpty();

    }

}

 

ArrayList练习（集合的元素是学生对象，并去除相同元素）

import java.util.*;

//List集合判断元素是否相同依据的是元素的equals方法。

publicclass ArrayListTest

{

    publicstaticvoid main(String[] args) {

    ArrayList al=new ArrayList();

    al.add(new student("lisi1",26));

    al.add(new student("lisi2",27));

    al.add(new student("lisi3",28));

    al.add(new student("lisi2",27));

al.add(new student("lisi4",29));

al=singleElement(al);

al.remove(new student("lisi2",27));//调用对象的equals方法

    Iterator it=al.iterator();

    while(it.hasNext())

    {

       studentstu=(student)it.next();

       sop(stu.getName()+"::"+stu.getAge());

    }

    }

    publicstaticvoid sop(Object obj)

    {

       System.out.println(obj);

    }

    publicstatic ArrayList singleElement(ArrayList al)

    {

       ArrayList newal=new ArrayList();

       Iterator it=al.iterator();

       while(it.hasNext())

       {

           Object obj=it.next();

           if(!newal.contains(obj))

              newal.add(obj);

       }

       return newal;

    }

}

class student

{

private Stringname;

privateintage;

student(Stringname,int age)

{

    this.name=name;

    this.age=age;

}

//覆盖父类Object中的equals方法

public boolean equals(Object obj)

{

    if(!(objinstanceof student))

       return false;

    student stu=(student)obj;

    returnthis.name.equals(stu.name)&&this.age==stu.age;  

}

public String getName()

{

    returnname;

}

publicint getAge()

{

    returnage;

}

}

 

|--List:元素是有序的，元素可以重复，因为该集合体系有索引。

   |--ArrayList：底层的数据结构使用的是数组数据结构。特点：查询速度很快，但是增删稍慢。线程不同步，效率高。

   |--LinkedList：底层使用的是链表数据结构。特点：增删速度很快，查询稍慢

   |--Vector:底层是数组数据结构。线程同步（Vector类多了一种特有的的元素取出方式Enumeration，现已被Itearator代替）

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

   |--HashSet:底层数据结构是哈希表。

             Hashset是如何保证元素唯一性的呢？

             是通过元素的两个方法，hashcode和equals来完成的

             如果元素的Hashcode值相同，才会判断equals是否为true。

             如果元素的Hashcode值不同，不会调用equals.

 

注意：对于判断元素是否存在，以及删除等操作，依据的方法是元素的hashcode和equals方法。

   |--TreeSet：可以对Set集合中的元素进行排序。

                底层数据结构是二叉树。

                保证元素唯一性的依据：

                compareTo return 0.

 

TreeSet排序的第一种方式：让元素自身具备比较性。

元素需要实现Comparable接口，覆盖compareTo方法。

这种方式也称为元素的自然顺序，或者叫做默认顺序。

 

Comparabel接口实现举例：

import java.util.*;

 

publicclassTreeSet_comparable {

    publicstaticvoid main(String[] args) {

          TreeSet ts=new TreeSet();

          ts.add(new Person("lisi1",26));

          ts.add(new Person("lisi2",27));

          ts.add(new Person("lisi3",28));

          ts.add(new Person("lisi2",28));

          ts.add(new Person("lisi2",27));

          ts.add(new Person("lisi1",29));

          Iterator it=ts.iterator();

          while(it.hasNext())

          {

              Person p=(Person)it.next();

              System.out.println(p.getName()+"------"+p.getAge());

          }

    }

}

class Personimplements Comparable

{

private Stringname;

privateintage;

Person(String name,int age)

{

    this.name=name;

    this.age=age;

}

//覆盖父类Object中的equals方法

publicintcompareTo(Object obj) //这里传进来的对象必须是Object的，否则不算覆盖

{

 

    if(!(objinstanceof Person))

        thrownew RuntimeException("不是人对象");

    Personpe=(Person)obj;

    if(this.age>pe.age)

        return 1;

    if(this.age==pe.age)

    {

        returnthis.name.compareTo(pe.name);//年龄相同则比较姓名

    }

    elsereturn -1;

}

public String getName()

{

    returnname;

}

publicintgetAge()

{

    returnage;

}

}

 

TreeSet的第二种排序方式。

当元素自身不具备比较性时，或者具备的比较性不是所需要的。

这时就需要让集合自身具备比较性，在集合初始化时，就有了比较方式。

定义一个比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。

 

当两种排序都存在时，以比较器为主。

定义比较器：定义一个类，实现Comparator接口，覆盖compare方法。

 

TreeSet实现Comparator接口排序举例：

import java.util.*;

 

publicclassTreeSet_Comparator {

 

    publicstaticvoid main(String[] args) {

         TreeSet ts=new TreeSet(new MyCompare());

          ts.add(new Person("lisi1",26));

          ts.add(new Person("lisi2",27));

          ts.add(new Person("lisi3",28));

          ts.add(new Person("lisi5",28));

          ts.add(new Person("lisi2",28));

          ts.add(new Person("lisi4",29));

          Iterator it=ts.iterator();

          while(it.hasNext())

          {

              Person p=(Person)it.next();

              System.out.println(p.getName()+"------"+p.getAge());

          }

    }

}

class MyCompareimplements Comparator

{

    publicint compare(Object o1,Objecto2)

    {

        Personp1=(Person)o1;

        Personp2=(Person)o2;

        int i=p1.getName().compareTo(p2.getName());

        if(i==0)

            returnp1.getAge()-p2.getAge();

        return i;

    }

}

 

 

|--Map

   |--Hashtable:底层是哈希表数据结构，不可以存入null键null值，该集合是线程同步的。

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

   |--Treemap:底层是二叉树数据结构，线程不同步，可以用于给map集合中的键排序。

 

Map集合：该集合存储键值对，一对一对往里存，而且要保证键的唯一性

1.添加

put(Kkey,V value)

putAll(Map<?extends K,?Extends V> m)

2.删除

clear()

remove(Objectkey)

3.判断

containsValue(Objectvalue)

containsKey(Objectkey)

isEmpty()

4.获取

get(Objectkey)

size()

value()

entrySet()

keySet()

 

 

HashMap:；如果出现添加值到相同的键上，后添加的值会覆盖先添加的值，并且put键返回该键原来对应的值。

Map集合的两种取出方式：

1. keySet:将map中所有的键存入到set集合，因为set具备迭代器。

所以可用迭代方式取出所有的键，再根据get方法，获取每一个键对应的值。Map.get(key);

Map集合的取出原理，将map集合转成set集合，再通过迭代器取出。

2.Set<>entrySet;

Map.Entry：其实Entry也是一个接口，它是Map接口中的一个内部接口。

Set<k>Keyset:将map中所有的健存入到set集合，因为set具备迭代器。

  所以可用迭代方式取出所有的键，再根据get方法，获取每一个键对应的值。

Set<Map.Entry<k,v>>entrySet():将map集合中的映射关系存入到set集合中，而这个关系的数据类型就是：Map.Entry。

 

HashMap的两种元素取出方式代码举例：

 

import java.util.*;

 

publicclassMapDemo {

 

    publicstaticvoid main(String[] args) {

    HashMap<student2,String>m=newHashMap<student2,String>();

    m.put(new student2("zhangsan",18),"BeiJing");

    m.put(new student2("lisi",19),"HongKong");

    m.put(new student2("lisi",19),"TianJin");

    m.put(new student2("wangwu",28),"TaiWan");

    m.put(new student2("tanqi",38),"AoMen");

    Set<student2>key=m.keySet();//使用keySet

    Iteratorit=key.iterator();

    while(it.hasNext())

    {

        student2stu=(student2)it.next();

        System.out.println(stu.getName()+" "+stu.getAge()+" years old,comes from "+m.get(stu));

    }

    Set<Map.Entry<student2,String>> EntrySet=m.entrySet();//使用EntrySet

    Iterator<Map.Entry<student2, String>> entit=EntrySet.iterator();

    while(entit.hasNext())

    {

        Map.Entry<student2,String> me=entit.next();

        student2s=me.getKey();

        Stringaddr=me.getValue();

        System.out.println(s.getName()+" "+s.getAge()+" "+"---"+addr);

    }

    }

}

class student2implements Comparable<student2>

{

    private Stringname;

    privateintage;

    student2(Stringname,intage)

    {

        this.name=name;

        this.age=age;

    }

    publicint compareTo(student2 s)//实现比较性

    {

        int num=new Integer(this.age).compareTo(s.age);

        if(num==0)

            returnthis.name.compareTo(s.name);

        return num;

    }

    public String getName()

    {

        returnname;

    }

    publicint getAge()

    {

        returnage;

    }

    publicint hashCode()//复写hashCode和equals方法

    {

        returnname.hashCode()+age*35;

    }

    publicboolean equals(Object obj)

    {

        if(!(objinstanceof student2))

            thrownew ClassCastException("元素类型不匹配！");

        student2stu=(student2)obj;

        returnthis.name.equals(stu.name)&&this.age==stu.age;

    }

}

 

运行结果：lisi19 years old,comes from TianJin

tanqi 38 years old,comes from AoMen

zhangsan 18 years old,comes fromBeiJing

wangwu 28 years old,comes fromTaiWan

lisi 19 ---TianJin

tanqi 38 ---AoMen

zhangsan 18 ---BeiJing

wangwu 28 ---TaiWan

 

注意：将数组变成集合，不可以使用集合的增删方法，因为数组的长度是固定的。

Contains,get,indexOf(),subList()可以使用。

如果你增删，那么会发生UnsupportedOperationException。

 

如果数组中的元素是对象，那么变成集合时，数组中的元素就直接转成集合中的元素。

如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。

 

Arrays使用举例：

 

import java.util.*;

 

publicclassArraysDemo {

 

    publicstatic void main(String[] args) {

        int []arr={1,2,6};

        System.out.println(Arrays.toString(arr));

List list = Arrays.asList(arr);//如果数组的数据为基本数据类型，则将数组//转换成集合时，将整个数组作为集合的一个元素

        System.out.println(list);

        Integer[]in={1,2,6};

        Listli=Arrays.asList(in);

        li.set(1,9);//add和remove方法不能使用，因为数组的长度是固定的。

        System.out.println(li);

        }

}

 

集合变数组

1.指定类型的数组到底要定义多长呢？

当指定类型的数组长度小于了集合的size,那么该方法内部会创建一个新的数组，长度为集合的size。

当指定类型的数组长度大于了集合的size，就不会新创建数组，而是使用传递进来的数组。

所以创建一个刚刚好的数组最优。

 

为什么要将集合变数组？

为了限定对元素的操作，不允许对数据进行增删。

 

集合变数组举例：

import java.util.*;

 

publicclassCollectionToArray {

 

    publicstaticvoid main(String[] args) {

    ArrayList<String> al=new ArrayList <String> ();

    al.add("zhangsan1");

    al.add("zhangsan2");

    al.add("zhangsan3");

    String[]str=al.toArray(newString [al.size()]);

    System.out.println(Arrays.toString(str));

    }

}

 

 

Date  将模式封装到SimpleDateFormat对象中。

调用format方法让模式格式化指定Date对象。

 

Data对象方法举例：

import java.text.*;

import java.util.*;

publicclassDataDemo {

   

     publicstaticvoidmain(String[] args)throws Exception

     {

       Date d=new Date();

       System.out.println(d);

       SimpleDateFormat dsf=new SimpleDateFormat("yyyy年MM月dd日Ekk时mm分ss秒");

       String time=dsf.format(d);

       System.out.println(time);

     }

}

 

Calendar类

方法调用举例：（从键盘录入获取任一年份值，求出该年份的二月有多少天）

 

import java.io.*;

import java.text.*;

import java.util.*;

 

publicclassCalendarDemo {

 

    publicstaticvoid main(String[] args)throws Exception

    {

        Calendarc=Calendar.getInstance();

        while(true)

        {

        BufferedReaderbuf=newBufferedReader(newInputStreamReader(System.in));

        Stringstr=buf.readLine();

        if(!str.equals("over"))

        {

            int ye=Integer.parseInt(str);      

            c.set(ye,2,1);

            c.add(Calendar.DAY_OF_MONTH, -1);

            Dated=c.getTime();

            SimpleDateFormatsdf=newSimpleDateFormat("yyyy年MM月，共有dd日");

            Stringtime=sdf.format(d);

            System.out.println(time);

            continue;

        }

        break;

        }

    }

}

 

Math

Ceil返回大于等于指定数据的最小整数

Floor返回小于等于指定数据的最大整数

Round四舍五入

Pow幂运算 pow(a,b)

 

Math类方法举例：

 

import java.util.Random;

 

publicclassMathDemo {

 

    publicstaticvoid main(String[] args) {

    Randomr=newRandom();//两种生成随机数的方法

    for(int x=0;x<10;x++)

    {

        int d=r.nextInt(10)+1;//不需强转类型

        System.out.println(d);

    }

    for(int x=0;x<10;x++)

    {

        double d=(int)(Math.random()*10+1);

        System.out.println(d);

    }

    test();

    }

    publicstaticvoid test()

    {

        double d=Math.abs(-7);

        double d1=Math.ceil(17.28);//返回大于给定数的最小整数

        double d2=Math.floor(17.28);//返回小于给定数的最大整数

        double d3=Math.pow(3,3);//3的3次方

        double d4=Math.round(12.30);//四舍五入

        System.out.println(d);

        System.out.println(d1);

        System.out.println(d2);

        System.out.println(d3);

        System.out.println(d4);

    }

}

 

List、Map、Set三个接口，存取元素时，各有什么特点？

        首先，List与Set具有相似性，它们都是单列元素的集合，所以，它们有一个共同的父接口，叫Collection。Set里面不允许有重复的元素，所谓重复，即不能有两个相等（注意，不仅仅是相同）的对象 ，即假设Set集合中有了一个A对象，现在我要向Set集合再存入一个B对象，但B对象与A对象equals相等，则B对象存储不进去，所以，Set集合的add方法有一个boolean的返回值，当集合中没有某个元素，此时add方法可成功加入该元素时，则返回true，当集合含有与某个元素equals相等的元素时，此时add方法无法加入该元素，返回结果为false。Set取元素时，没法说取第几个，只能以Iterator接口取得所有的元素，再逐一遍历各个元素。
        List表示有先后顺序的集合， 注意，不是那种按年龄、按大小、按价格之类的排序。当我们多次调用add(Object)方法时，每次加入的对象就像火车站买票有排队顺序一样，按先来后到的顺序排序。有时候，也可以插队，即调用add(int index,Object)方法，就可以指定当前对象在集合中的存放位置。一个对象可以被反复存储进List中，每调用一次add方法，这个对象就被插入进集合中一次，其实，并不是把这个对象本身存储进了集合中，而是在集合中用一个索引变量指向这个对象，当这个对象被add多次时，即相当于集合中有多个索引指向了这个对象，如图x所示。List除了可以以Iterator接口取得所有的元素，再逐一遍历各个元素之外，还可以调用get(index i)来明确说明取第几个。        Map与List和Set不同，它是双列的集合，其中有put方法，定义如下：put(obj key,obj value)，每次存储时，要存储一对key/value，不能存储重复的key，这个重复的规则也是按equals比较相等。取则可以根据key获得相应的value，即get(Object key)，返回值为key 所对应的value。另外，也可以获得所有的key的集合，还可以获得所有的value的集合，还可以获得key和value组合成的Map.Entry对象的集合。List 以特定次序来持有元素，可有重复元素。Set 无法拥有重复元素,内部排序。Map 保存key-value值，value可多值。
        HashSet按照hashcode值的某种运算方式进行存储，而不是直接按hashCode值的大小进行存储例如，"abc" ---> 78，"def" ---> 62，"xyz" ---> 65在hashSet中的存储顺序不是62,65,78。LinkedHashSet按插入的顺序存储，那被存储对象的hashcode方法还有什么作用呢？hashset集合比较两个对象是否相等，首先看hashcode方法是否相等，然后看equals方法是否相等。new 两个Student插入到HashSet中，看HashSet的size，实现hashcode和equals方法后再看size。同一个对象可以在Vector中加入多次。往集合里面加元素，相当于集合里用一根绳子连接到了目标对象。往HashSet中却加不了多次的。 

 

------ android培训、 java培训、期待与您交流！ ----------