黑马程序员_java_集合(上)

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

         集合类
 java语言的java.util包中提供了一些集合类,这些集合又被成为容器,提到容器不难会想象到数组,集合类与数组的不同之处,
书中的长度是固定的,集合的长度是可变的:数组用来存放基本类型的数据,集合用来存放对象的引用,集合有List集合,Set集合,Map集合,
其中List和Set集合是想了Coll接口,个个接口还提供了不同的实现类.
 

Collection
 |-----List---:元素是有序的,元素可以重复。因为该集合体系有索引。
          |----ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。
          |----LinkedList:底层使用的链表数据结构。特点：增删速度很快,查询稍慢。线程不同步。
          |----Vector:底层是数组数据结构。线程同步。被ArrayList替代了因为效率低。

 |-----Set ---Set集合的功能和Collection是一致的。元素是无序(存入和取出的顺序不一定一致),元素不可以重复,其存储顺序是按哈希值顺序。
          |----HashSet:底层数据结构是哈希表。是线程不安全的。不同步。
                      HashSet是如何保证元素唯一性的呢？
                      是通过元素的两个方法,hashCode和equals来完成。
                      如果元素的HashCode值相同,才会判断equals是否为true。
                       如果元素的hashcode值不同,不会调用equals。
                       注意,对于判断元素是否存在,以及删除等操作,依赖的方法是元素的hashcode和equals方法。
          |----TreeSet:可以对Set集合中的元素进行排序。
                                 底层数据结构是二叉树。
                                 保证元素唯一性的依据：compareTo方法return 0.

                                 TreeSet排序的第一种方式：让元素自身具备比较性。元素需要实现Comparable接口,覆盖compareTo方法。
也种方式也成为元素的自然顺序,或者叫做默认顺序。

                                 TreeSet的第二种排序方式： 当元素自身不具备比较性时,或者具备的比较性不是所需要的。这时就需要让集

合自身具备比较性。在集合初始化时,就有了比较方式。定义一个类,实现Comparator接口,覆盖compare方法。

//--------------------------华丽的分割线-----------------------------

Collection 接口集合框架的共性功能。

1,添加
  add(e);
  addAll(collection);

2,删除
  remove(e);
  removeAll(collection);
  clear();

3,判断。
  contains(e);
  contains(collection);
  isEmpty();
  equals(Object o);// o - 要与此 collection 进行相等性比较的对象, 如果所定义的两个列表以相同的顺序包含相同的元素,那么它们是相等的

4,获取
  iterator();//获取迭代器
  size();//获取元素个数

5, 仅保留此 collection 中那些也包含在指定 collection 的元素
  retainAll(collection);

6,移除此 collection 中那些也包含在指定 collection 中的所有元素
   removeAll(collection);

7,集合变数组。
  toArray(); 返回Object[]
  toArray(T[] t);返回T[]数组到t

 

注意：
 1,add方法的参数类型是Object。以便于接收任意类型对象。
 2,集合中存储的都是对象的引用(地址)

//--------------------------华丽的分割线-----------------------------

 

Iterator 类

1,什么是迭代器呢？
 迭代器是取出方式,会直接访问集合中的元素。
 所以将迭代器通过内部类的形式来进行描述。
 通过容器的iterator()方法获取该内部类的对象。

2,定义迭代器
Iterator it = 集合名. iterator();
3,迭代器方法
  boolean  hasNext();//如果仍有元素可以迭代,则返回 true。
                it.hasNext();//返回迭代的下一个元素。
  E  next();//返回迭代的下一个元素
  it.next();
  void  remove();//从迭代器指向的 collection 中移除迭代器返回的最后一个元素
        it.remove();

//--------------------------华丽的分割线-----------------------------

 

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

1,添加
 add(index,element);
 addAll(index,Collection);

2,删除
 remove(index);

3,修改
 set(index,element);

4,查
 get(index):
 subList(from,to);
 listIterator();
 int indexOf(obj)://获取指定元素第一次的位置。
 int lastIndexOf(obj)// 获取指定元素最后一次的位置
 ListIterator listIterator();//List集合特有迭代器

//----------------华丽的分割线-----------------------------

 

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

 2,  定义迭代器
 ListIterator it = List集合名. listIterator();

3,特有方法
 hasPrevious()//判断是否前边还有元素,有返回true
 previous()//返回列表中的前一个元素。
 previousIndex()//返回前一个元素的索引。
 nextIndex()//返回后一个元素的索引。
 set(E e) // 用指定元素替换 next 或 previous 返回的最后一个元素
 remove()// 从列表中移除由 next 或 previous 返回的最后一个元素

4,注意：
 在迭代时,不可以通过集合对象的方法操作集合中的元素。
 因为会发生ConcurrentModificationException异常。
 所以,在迭代器时,只能用迭代器的放过操作元素,可是Iterator方法是有限的,
 只能对元素进行判断,取出,删除的操作,
 如果想要其他的操作如添加,修改等,就需要使用其子接口,ListIterator。
 该接口只能通过List集合的listIterator方法获取。

//--------------------------华丽的分割线-----------------------------

LinkedList

1,特有方法：
 addFirst(e);
 addLast(e); add(e);
 getFirst();
 getLast();
获取元素,但不删除元素。如果集合中没有元素,会出现NoSuchElementException
 removeFirst();
 remove();
 removeLast();
获取元素,但是元素被删除。如果集合中没有元素,会出现NoSuchElementException
在JDK1.6出现了替代方法。
 offerFirst(e);
 offerLast(e);  offer(e);
 peekFirst();  peek();
 peekLast();
获取元素,但不删除元素。如果集合中没有元素,会返回null。
 pollFirst();  poll();
 pollLast();
获取元素,但是元素被删除。如果集合中没有元素,会返回null。
 push(e)// 将元素推入此列表所表示的堆栈。
 pop()//从此列表所表示的堆栈处弹出一个元素。

2,  注意 contains 和remove方法底层也是依赖于元素的equals方法           
List集合判断元素是否相同,依据是元素的equals方法。
所以元素需复写该方法

//--------------------------华丽的分割线-----------------------------

HashSet

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

2,  HashSet是如何保证元素唯一性的呢？
是通过元素的两个方法,hashCode和equals来完成。
如果元素的HashCode值相同,才会判断equals是否为true。
       如果元素的hashcode值不同,不会调用equals。

3,  注意, 对于判断元素是否存在,以及删除等操作,依赖的方法
是元素的hashcode和equals方法。所以元素需复写这两个方法
     HashSet hs = new HashSet();

 

ps:
 有很多同学关于覆盖hashCode和equals这里分不清楚(当时我也有点蒙).特意写的非常详细,傻瓜都能看懂
 public int hashCode()
 {
 /*
 这个是为了保证元素在存入到底层为Hash值的集合时不重复。HashSet和HashMap的底层都是Hash值结构，通过hash值来保证元素的唯一。
 当Students对象被存入到HashSet或者HashMap中时， hm.put(new Student("lisi1",21),"beijing"),这时new Student("lisi1",21)作为一个匿名对象出现，
 这个对象会有自己的一个Hash值(具体Hash值的算法我也不知道)。当你再往集合中存入new Student("lisi1",21)时，又会在内存中出现一个匿名对象，
 他们的Hash值是不同的！所以，如果你的Students类不复写hashCode方法，这两个new Student("lisi1",21),"beijing")都会被存入进去！
 但是当你复写了hashCode方法以后，这两个匿名对象都不会按照以前的那个方法计算hash值了，而是按照你给定的方法计算各自的hash值。
 */
 return name.hashCode()+age*34;
 /*
 这个是指你想让Students类怎样计算自己的Hash值。默认Hash值的算法是很麻烦的，基本上new一个对象就有一个hash值。但是你自己手动复写了hash值算法，
 让他们只比较姓名和年龄，这样的话hash值就会相同。例如：new Student("lisi1",21)，如果按照默认的算法，hash值为11223344，当你再new一个Student("lisi1",21)，
 按照默认算法，hash值可能就变成了33445566。但是你的目的是想让姓名年龄相同视为同一个人，所以你就让他们的只比较姓名和年龄这两个元素就可以了。
 name.hashCode().是字符串本身就具备了hashCode()方法.age*34是为了Hash值偶然相同。比方说，"lisi"字符串的Hash值为40,年龄为20, 而"wangwu"字符串的hash值为32，
 年龄为28，name.hashCode()+age都等于60.为了避免出现这样的情况，让就age随便乘以一个基数，那样 40+20*34就不再等于32+28*34了
 */
 }
 public boolean equals(Object obj)
 /*
 当Hash值相同时，才会调用equals方法对照内容进行比较。比方说，"lisi".hashCode()=40,age =20, "wangwu".hashCode()=720,age=0,
 那么lisi.hashCode()+age*34正好等于 wangwu.hashCode()+age*34，但是这两个人却不是同一个人！所以此时就需要调用equals方法对内容进行比较！
 */
 {
 if(!(obj instanceof Student))
  throw new ClassCastException("类型不匹配");
  Student s=(Student)obj;
  return this.name.equals(s.name) && this.age==s.age;
 //对学生的姓名和年龄进行比较，如果返回为true，那就说明这个学生已经存入到了集合中，不会再存入，即集合中已经有了一个lisi,20，反之，则存入
 }

//--------------------------华丽的分割线-----------------------------

TreeSet1, 
可以对Set集合中的元素进行排序。
底层数据结构是二叉树。

 

保证元素唯一性的依据：

compareTo方法return 0. 2,  TreeSet排序的第一种方式：
让元素自身具备比较性。元素需要实现Comparable接口,覆盖compareTo方法。
也种方式也成为元素的自然顺序,或者叫做默认顺序。
TreeSet ts = new TreeSet();

示例:

class Student implements Comparable//该接口强制让学生具备比较性。
{
 private String name;
 private int age;
 Student(String name,int age)
 {
  this.name = name;
  this.age = age;
 }
 public int compareTo(Object obj)
 {
  if(!(obj instanceof Student))
   throw new RuntimeException("不是学生对象");
  Student s = (Student)obj;
  if(this.age>s.age)
   return 1;
  if(this.age==s.age)
  {
   return this.name.compareTo(s.name);
  }
  return -1;
 }
  public String getName()
 {
  return name;
 }
 public int getAge()
 {
  return age;
 }
}

3,  TreeSet排序的第二种方式：
 当元素自身不具备比较性时,或者具备的比较性不是所需要的。这时就要让集合自身具备比较性。
 在集合初始化时,就有了比较方式。

定义一个类,实现Comparator接口,覆盖compare方法。
示例:

TreeSet ts = new TreeSet(MyCompare);
class MyComart implements Comparator//定义一个类,实现Comparator接口,覆盖compare方法。
{
 public int compare(Object o1,Object o2)//覆盖compare方法。
 {
  Student s1 = (Student)o1;
        Student s2 = (Student)o2;
  int num = s1.getName().compareTo(s2.getName());
        if(num==0)
  {
   return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));//比较年龄因为Intege已经具有比较性了.直接比就可以啦
               /*
               if(s1.getAge()>s2.getAge())
                      return 1;
               if(s1.getAge()==s2.getAge())
                      return 0;
               return -1;
               */
        }
        return num;
 }
}

 

须知:
 当元素自身不具备比较性,或者具备的比较性不是所需要的。
 这时需要让容器自身具备比较性。
 定义了比较器,将比较器对象作为参数传递给TreeSet集合的构造函数。
 当两种排序都存在时,以比较器为主。

---------------------------------------------------------------------

 

                                 泛型
泛型：

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

好处:
1.将运行时期出现问题ClassCastException,转移到了编译时期。
 方便于程序员解决问题。让运行时问题减少,安全。,
2,避免了强制转换麻烦。

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

在使用java提供的对象时,什么时候写泛型呢？
 通常在集合框架中很常见,
 只要见到< >就要定义泛型。
其实< > 就是用来接收类型的。
当使用集合时,将集合中要存储的数据类型作为参数传递到< >中即可。
? 通配符。也可以理解为占位符。
//--------------------------华丽的分割线-----------------------------
泛型的限定；
？ extends E: 可以接收E类型或者E的子类型。上限。
？ super E: 可以接收E类型或者E的父类型。下限
//--------------------------华丽的分割线-----------------------------
示例:

import java.util.*;
class GenericDemo 
{
 public static void main(String[] args) 
 {
  ArrayList<String> al = new ArrayList<String>();
  al.add("abc01");
  al.add("abc0991");
  al.add("abc014");
  //al.add(4);//al.add(new Integer(4));
  Iterator<String> it = al.iterator();
  while(it.hasNext())
  {
   String s = it.next();
   System.out.println(s+":"+s.length());
  }
 }
}

//--------------------------华丽的分割线-----------------------------

泛型类

1什么时候定义泛型类？
当类中要操作的引用数据类型不确定的时候,
早期定义Object来完成扩展。
现在定义泛型来完成扩展。

2,   泛型类定义的泛型,在整个类中有效。如果被方法使用,那么泛型类的对象明确要操作的具体类型后,所有要操作的类型就已经固定了。
为了让不同方法可以操作不同类型,而且类型还不确定。那么可以将泛型定义在方法上。
特殊之处：
静态方法不可以访问类上定义的泛型。
如果静态方法操作的应用数据类型不确定,可以将泛型定义在方法上。
示例:

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);
 }
}
class GenericDemo4 
{
 public static void main(String[] args) 
 {
  Demo <String> d = new Demo<String>();
  d.show("haha");
  d.print(5);
  d.print("hehe");
  Demo.method("hahahahha");
 }
}

 

泛型定义在接口上
示例:

interface Inter<T>
{
 void show(T t);
}
class InterImpl<T> implements Inter<T>
{
 public void show(T t)
 {
  System.out.println("show :"+t);
 }
}
class GenericDemo5 
{
 public static void main(String[] args) 
 {
  InterImpl<Integer> i = new InterImpl<Integer>();
  i.show(4);
 }
}

 

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