黑马程序员_java基础部分_集合

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

对集合,泛型,高级for循环知识点的总结

1.         集合的特点：

集合的长度是可变的；集合可以存储不同类型的对象；

Collection定义了集合框架的共性功能。

一、添加

 add(e);       //e是形式参数的意思，没什么特别的，就是元素的意思；

 addAll(collection);

二、删除

 remove(e);

 removeAll(collection);

clear();

三、判断。

 contains(e);

 isEmpty();

四、获取

iterator();

Iterator it = al.iterator();//获取迭代器，用于取出集合中的元素。

                     while(it.hasNext())

                    {

                            sop(it.next());

                     }

size();

五、获取交集。

 retainAll();

六、集合变数组。

 toArray();

 1，add方法的参数类型是Object。以便于接收任意类型对象。

 2，集合中存储的都是对象的引用(地址)

 什么是迭代器呢？

 其实就是集合的取出元素的方式。

迭代器是取出方式，会直接访问集合中的元素。

 所以将迭代器通过内部类的形式来进行描述。

 通过容器的iterator()方法获取该内部类的对象。

2.         对Collection进行总结；

list集合中特有的方法

Collection

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

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

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

|--Vector:底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。

 

|--Set：元素是无序，元素不可以重复。、

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

增

         add(index,element);

         addAll(index,Collection);

 

删

         remove(index);

 

改

         set(index,element);

查

         get(index):

         subList(from,to);

         listIterator();

         int indexOf(obj):获取指定元素的位置。

         ListIterator listIterator();

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

在迭代时，Iterator不可以通过集合对象的方法操作集合中的元素。

因为会发生ConcurrentModificationException异常。

所以我们只能用ListIterator。接口里面的方法，来操作异常

 

所以，在迭代器时，只能用迭代器的方法操作元素，可是Iterator方法是有限的，

只能对元素进行判断，取出，删除的操作，                 

如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator。

该接口只能通过List集合的listIterator方法获取。

代码的体现；

/**

 * 演示列表迭代器。

 * 使用方式：在迭代过程中，准备添加和修改元素的时候，不能用Iterator。

 * 因为Iterator里面之后移除方法，没有添加和修改等方法，

 * 所以会包ConcurrentModificationException异常

 */  

                   ListIterator<String> li = al.listIterator();         

                   //sop("hasPrevious():"+li.hasPrevious());

                   while(li.hasNext())

                   {

                            String s = li.next();

                            if(s.equals("java02"))

                //这里面我们就添加了元素。要是用Iterator就会产生

                //ConcurrentModificationException异常，这个是并发访问异常。

//                                  li.add("java009");

                                     li.set("java006");

                   }

3.         去除ArrayList集合中的重复元素,用循环的方式，判断有没有一样的元素，然后去掉重复元素；因为list是有序的，可以重复的；

while(it.hasNext())

                   {

                            String str = it.next();

//                         不包含此元素，我们就添加，包含我们就不添加此元素了；

                            if(!newAl.contains(str))

                                     newAl.add(str);

                   }

                   return newAl;

4.         将自定义对象作为元素存到ArrayList集合中，并去除重复元素。

比如：存人对象。同姓名同年龄，视为同一个人。为重复元素。

思路：

1，对人描述，将数据封装进人对象。

2，定义容器，将人存入。

3，取出。

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

//      判断同一个元素，我们要重写equals方法。这个只是用来告诉我们怎么判断元素相同。

//      去除重复元素的代码还要重新写；重点；

         public boolean equals(Object obj)

         {

                   if(!(obj instanceof Person))

                            return false;

                   Person p = (Person)obj;

                   //System.out.println(this.name+"....."+p.name);

                   return this.name.equals(p.name) && this.age == p.age;

         }

然后还是利用包含特性，存到新的容器中去，因为毕竟list集合是可以存放重复元素的；

         while(it.hasNext())

                   {

                            Person p = it.next();

//                         也是利用人一个新的集合来判断是否有相同的对象。来去除同一个元素的。

//                         判断的底层用到了equels方法；

                            if(!newAl.contains(p))

                                     newAl.add(p);

                   }

                   return newAl;

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

         |--HashSet:底层数据结构是哈希表。是线程不安全的。不同步。

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

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

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

                            如果元素的hashcode值不同，不会调用equals。

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

         |--TreeSet：

            Set集合的功能和Collection是一致的。

 

本身是无序的，不可重复的，所以添加的元素不需要去除重复元素；

但是添加的是对象就不同了，需要判断一下是不是重复元素；

public int hashCode()

         {

//字符串本身就有hashCode值，这里面体现了元素的唯一性，age*37也是在保证元素的唯一性。

                   return name.hashCode()+age*37;

         }

public boolean equals(Object obj)

         {

                   if(!(obj instanceof Person01))

                            return false;

                   Person01 p = (Person01)obj;

                   return this.name.equals(p.name) && this.age == p.age;

         }

6.         Set:无序，不可以重复元素。

         |--HashSet：数据结构是哈希表，线程是非同步的。

                                     保证元素唯一性的原理：判断元素的hashCode值是否相同。

                                     如果相同，还会继续判断元素的equals方法，是否为true。

         |--TreeSet：    可以对Set集合中的元素进行排序，有自身排序的功能。

                                    底层数据结构是二叉树。

                                     保证元素唯一性的依据：

                                     compareTo方法return 0.

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

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

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

                            TreeSet的第二种排序方式。

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

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

                                这时就需要让集合自身具备比较性。

                                     在集合初始化时，就有了比较方式。

记住，排序时，当主要条件相同时，一定判断一下次要条件。

一、具有比较性的代码；

class Studenter implements Comparable

{

public int compareTo(Object obj)

         { 

                   if(!(obj instanceof Studenter))

                            throw new RuntimeException("不是学生对象");

                   Studenter s = (Studenter)obj;

                   if(this.age>s.age)

                            return 1;

                   if(this.age==s.age)

                   {

                            return this.name.compareTo(s.name);

                   }

                   return -1;

         }       

二、具有比较器的代码；

//定义比较器；

class StrLenComparator implements Comparator<String> {

         public int compare(String s1, String s2) {

                   // 因为长度的值是一个整形，所以我们通过转化成整形对象的方式，来进行判断顺序问题；

                   int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));

                   if (num == 0)

                            // 这个是二级判断，字符串本身就具备比较性；

                            return s1.compareTo(s2);

                   return num;

         }

7.         LinkedList:特有方法：

addFirst();

addLast();

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

getFirst();

getLast();

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

removeFirst();

removeLast();

 

在JDK1.6出现了替代方法。

添加元素

offerFirst();

offerLast();

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

peekFirst();

peekLast();

 

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

pollFirst();

pollLast();

使用LinkedList模拟一个堆栈或者队列数据结构。

堆栈：先进后出  如同一个杯子。

队列：先进先出 First in First out  FIFO 如同一个水管。

8.         枚举就是Vector特有的取出方式。

发现枚举和迭代器很像。

其实枚举和迭代是一样的。

//获得枚举接口对象；

Enumeration<String> en = v.elements();

//通过枚举对象调用里面的方法，进行遍历；

while(en.hasMoreElements())

{

System.out.println(en.nextElement());

}

9.         泛型：JDK1.5版本以后出现新特性。用于解决安全问题，是一个类型安全机制。

好处

1.将运行时期出现问题ClassCastException，转移到了编译时期。，

         方便于程序员解决问题，让运行时,问题减少，安全。

2，避免了强制转换麻烦。

泛型格式：通过<>来定义要操作的引用数据类型。

在使用java提供的对象时，什么时候写泛型呢？

通常在集合框架中很常见，

只要见到<>就要定义泛型。

其实<> 就是用来接收类型的。

当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。

10.     下面这两种写法是一致的，因为装箱和拆箱的原理，java底层实现的功能

//al.add(4);

//al.add(new Integer(4));

11.     泛型类。

什么时候定义泛型类？

当类中要操作的引用数据类型不确定的时候，

早期定义Object来完成扩展。

现在定义泛型来完成扩展。

class Utils<QQ>

{

         private QQ q;

         public void setObject(QQ q)

         {

                   this.q = q;

         }

         public QQ getObject()

         {

                   return q;

         }

}

调用泛型类的时候就是这样的方便；

public static void main(String[] args)

         {

                   Utils<Worker> u = new Utils<Worker>();

                   u.setObject(new Worker());

                   Worker w = u.getObject();;

12.     //泛型类定义的泛型，在整个类中有效。如果被方法使用，

//那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。

//为了让不同方法可以操作不同类型，而且类型还不确定。

//那么可以将泛型定义在方法上。

特殊之处：

静态方法不可以访问类上定义的泛型。

如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。

class Demo<T>

{

//      方法的类型要和类的类型一致；

         public  void show(T t)

{

                   System.out.println("show:"+t);

         }

//      这个是自己定义的泛型，可以和类不一致；

         public <Q> void print(Q q)

         {

                   System.out.println("print:"+q);

         }

         public  static <W> void method(W t)

         {

                   System.out.println("method:"+t);

         }

13.     ? 通配符。也可以理解为占位符，泛型的限定；

？ extends E: 可以接收E类型或者E的子类型，上限。

？ super E: 可以接收E类型或者E的父类型，下限

//接收子类型的集合；这个是限定的集合；

         public static void printColl(Collection<? extends Person> al)

         {

                   Iterator<? extends Person> it = al.iterator();

                   while(it.hasNext())

                   {

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

                   }

         }

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

         1，添加。

//添加元素，如果出现添加时，相同的键，那么后添加的值会覆盖原有键，对应的值。

 //并put方法会返回被覆盖的值。

put(K key, V value)

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

//添加元素，如果出现添加时，相同的键，那么后添加的值会覆盖原有键对应值。

//并put方法会返回被覆盖的值，返回原来的值，要是没有原来的值，那么我们就返回null；

System.out.println("put:"+map.put("01","zhangsan1"));

         2，删除。

                   clear()

                   remove(Object key)

         3，判断。

                   containsValue(Object value)

                   containsKey(Object key)

                   isEmpty()

         4，获取。

                   get(Object key)

                   size()

                   values()

//可以通过get方法的返回值来判断一个键是否存在。通过返回null来判断

         //获取map集合中所有的值。

                   Collection<String> coll = map.values();

                   entrySet()

                   keySet()

Map

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

         |--HashMap：底层是哈希表数据结构，允许使用 null 值和 null 键，该集合是不同步的。将hashtable替代，jdk1.2.效率高。

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

和Set很像。

其实大家，Set底层就是使用了Map集合

15.     map集合的两种取出方式：

1，Set<k> keySet：将map中所有的键存入到Set集合，因为set具备迭代器。

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

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

2，Set<Map.Entry<k,v>> entrySet：将map集合中的映射关系存入到了set集合中，

                                     而这个关系的数据类型就是：Map.Entry

                                     Entry其实就是Map中的一个static内部接口。

                                     为什么要定义在内部呢？

                                     因为只有有了Map集合，有了键值对，才会有键值的映射关系。

                                     关系属于Map集合中的一个内部事物。

                                     而且该事物在直接访问Map集合中的元素。

                   //将Map集合中的映射关系取出。存入到Set集合中。

                   Set<Map.Entry<String,String>> entrySet = map.entrySet();

                   Iterator<Map.Entry<String,String>> it = entrySet.iterator();

 

                   while(it.hasNext())

                   {

//Map.Entry<String,String>是一个类型；是一个关系类型，所以可以接收对象引用；

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

                            String key = me.getKey();

                            String value = me.getValue();

                            System.out.println(key+":"+value);

 

                   }

第二种获取map元素集合的键值对；

//先获取map集合的所有键的Set集合,keySet();

                   Set<String> keySet = map.keySet();

                   //有了Set集合。就可以获取其迭代器。

                   Iterator<String> it = keySet.iterator();

                   while(it.hasNext())

                   {

                            String key = it.next();

                            //有了键可以通过map集合的get方法获取其对应的值。

                            String value  = map.get(key);

                            System.out.println("key:"+key+",value:"+value);

                   }

16.     注意我们可以通过set集合中的排序特点给map进行排序；我们这时用到的就是TreeMap，调用TreeMap里面的treeSet。TreeMap具有排序功能，

我们对元素进行去掉重复元素操作，我们用到的是hashMap，调用hashSet，hashMap具有去除重复的功能；

17.     高级for循环；

格式：

for(数据类型变量名 : 被遍历的集合(Collection)或者数组)

{       

}

对集合进行遍历。

只能获取集合元素。但是不能对集合进行操作。

迭代器除了遍历，还可以进行remove集合中元素的动作。

如果是用ListIterator，还可以在遍历过程中对集合进行增删改查的动作。

传统for和高级for有什么区别呢？

高级for有一个局限性。必须有被遍历的目标。

建议在遍历数组的时候，还是希望是用传统for，因为传统for可以定义脚标。

18.     JDK1.5版本出现的新特性。

19.     方法的可变参数。

在使用时注意：可变参数一定要定义在参数列表最后面。

可变参数。

其实就是上一种数组参数的简写形式。

不用每一次都手动的建立数组对象。

只要将要操作的元素作为参数传递即可。

隐式将这些参数封装成了数组。

在使用时注意：可变参数一定要定义在参数列表最后面。

可变参数必须是同一类型的参数；

public static void show(String str,int... arr)

         {

                   System.out.println(arr.length);

         }

20.     集合框架的工具类。

Collections:集合框架的工具类，里面定义的都是静态方法。

Collections和Collection有什么区别？

Collection是集合框架中的一个顶层接口，它里面定义了单列集合的共性方法。

                   它有两个常用的子接口，

                   List：对元素都有定义索引，有序的，可以重复元素。

                   Set：不可以重复元素，无序。

Collections是集合框架中的一个工具类，该类中的方法都是静态的

                   提供的方法中有可以对list集合进行排序，二分查找等方法。

                   通常常用的集合都是线程不安全的，因为要提高效率。

如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的。

                   Collections.sort(list);

                   Collections.max();

                   Collections.binarySearch();

         //默认的排序方式。也可以传入一个比较器，自定义排序；

         Collections.sort(list,new StrLenComparator());

//      一种是默认排序最大值，默认排序时按照字母排序的。

//      一种是自定义模式最大值。按照长度求的最大值；

                   String max = Collections.max(list/*,new StrLenComparator()*/);

 

排序和二分法查找必须定义一个比较器；要是不定义的话，就会出现找不到的可能；

Collections.sort(list,new StrLenComparator());

                   sop(list);

二分法查找元素，返回元素的位置值，要是没有查到元素，返回元素应该在的位置值的负数减去1.

int index = Collections.binarySearch(list,"aaa",new StrLenComparator());

 

21.     Collections.reverseOrder();

本方法是用来“逆转”容器里面的数据的，封装的很好。

使用方式，是在构造函数中传递，该方法。如下代码；

反向打印出通过长度来排序的元素；

TreeSet<String> ts =new

TreeSet<String>(Collections.reverseOrder(new StrLenComparatorln()));

Collections.shuffle(list);随机打乱顺序；

Collections.reverseOrder();倒序排序的方法；

所有的元素替换成指定的元素；

*Collections.fill(list,"pp");

替换相应的元素；

Collections.replaceAll(list,"aaa","pp");

*Collections.reverse(list);反向输出；

22.     为什么要将集合变数组？

为了限定对元素的操作。不需要进行增删了。

按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组。

al这个集合带着泛型呢。所以我们要用String类型；

String[] arr = al.toArray(new String[al.size()]);

将数组以字符串的形式打印出来

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