黑马程序员——java中容器（集合类）

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------

 

容器又叫集合类其中包括；Collction、Map，Collction又包括Set和list
集合框架接口的分类：（分collection接口 和 map接口）
          

 

Collection接口	Set接口	HashSet,TreeSet
	List接口	linkedlist
		Arraylist
Map接口	HashMap接口	Treemap

Collection:
 --Arraylist的特性：(底层是数组数据结构的，特点是查询快，但是增删慢，线程不同步的)
  1.增加:add()
  2.删除:remove(index(角标))
  3.修改:set(index(角标),emelment(数据));
  4.查  :get()  subList()  ListIterator()(list特有的共性)
 --LinkedList的特性：(底层使用的是链表数据结构的，查询慢，但是删除快)
  1.增加：addFirst(),addLast()
  2.删除：removeFirst(),removerLast()
  3.获取：getFirst(),getLast()

  JDK1.6的替代方法：
  offerFirst(),offerLast()
  peekFirst(),peekLast()
  pollFirst(),pollLast()

 --Vector的特性：(底层是数组数据结构，运行慢，线程同步，被ArrayList代替)

 同时List具有自己的迭代器：（ListIterator）

import java.util.*;
class  ListTest
{
 public static void main(String[] args) 
 {
  ArrayList al = new ArrayList();
  al.add("java1");
  al.add("java2");
  al.add("java3");
  al.add("java4");

  //修改”java2“
  al.set(1,"java007");

  ListIterator lit = al.listIterator();
  while(lit.hasNext())
  {
   Object obj = lit.next();
   if(obj.equals("java2"))
   {
    al.add("java008");
    lit.set("java009");
   }
  }
  System.out.println(al);
 }
}

|--Set:元素是无序的，而且不可以重复
 --hashSet(底层数据是哈希表，线程是非同步的)
 hasSet是如何保证数据唯一性的呢？
 是通过元素的两个方法；一个HashCode()、一个是equals()方法
 如果HashCode相同，则比较equals是否为true，如果HashCode值不相同，则不用比较equals
 
 注意：判断元素是否存在或删除等操作，都是依赖元素的两个方法HashCode和equals
 
 --TreeSet(底层数据是二叉树，可以对Set数据中的元素进行排序)
  保证数据唯一性的依据是compareTo方法返回return 0；

  TreeSet排序的方法有两种：
  第一种：让对象实现Comparable接口，让元素或则每个对象自己具有比较性，覆盖compareTo方法。
  这种方法也叫自然顺序，或则默认顺序
  第二种：让对象实现Comparator接口，让容器具备比较性

import java.util.*;
class mycompare implements Comparator
{
 public int compare(Object o1,Object o2)
 {
  Students s1 = (Students)o1;
  Students s2 = (Students)o2;
  return s1.getName().compareTo(s2.getName());
 }
}
class SetTest1 
{
 public static void main(String[] args) 
 {
  TreeSet ts = new TreeSet(new mycompare());
  ts.add(new Students("java01",1));
  ts.add(new Students("java007",11));
  ts.add(new Students("java01",11));
  ts.add(new Students("java02",1));
  ts.add(new Students("java03",1));

  Iterator it  = ts.iterator();
  while(it.hasNext())
  {
   Students  s = (Students)it.next();
   System.out.println(s.getName()+"::"+s.getAge());
  }
 }
}
class Students implements Comparable
{
 private String name;
 private int age;
 Students(String name,int age)
 {
  this.name = name;
  this.age = age;
 }
 public int compareTo(Object obj)
 {
  if(!(obj instanceof Students))
   throw new RuntimeException("不是学生对象");
  Students s = (Students)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;
 }
}

 Map:该集合存储键值对，一对一对往里存，而且要保证键的唯一性
  添加：put()
  删除：remove() ,clear()
  获取：keySet(),entrySet()
  --Hashtable(底层是哈希表结构，不可以存入null值和null键，该集合是线程同步的。效率低)
  --HashMap(底层是哈希表结构，可以存入null值和null键，该集合是不同步的。效率高)
  --TreeMap(底层是二叉树结构，线程不同步，可以给map集合中的键进行排序)

  两种获取方法：
   1.keySet：将map中的所有键存入set集合，因为set具有迭代器，在根据get方法取出值；
   2.将map集合中的映射关系存入到set集合中，这种关系数据类型是Map.Entry；

 

import java.util.*;
class MapTest1 
{
 public static void main(String[] args) 
 {
  Map<Integer,String> map = new HashMap<Integer,String>();
  map.put(1,"java01");
  map.put(2,"java02");
  map.put(3,"java03");
  map.put(4,"java04");
  //第一种取出方法：keyset()
  Set<Integer> keyset = map.keySet();

  Iterator<Integer> it = keyset.iterator();
  while(it.hasNext())
  {
   Integer key1 = it.next();
   String values1 = map.get(key1);
   System.out.println(key1+"::"+values1);
  }
  //第二种方法：Map.Entry
  Map<Integer,String> map1 = new HashMap<Integer,String>();
  map1.put(1,"java01");
  map1.put(2,"java02");
  map1.put(3,"java03");
  map1.put(4,"java04");
  
  Set<Map.Entry<Integer,String>> entryset = map1.entrySet();
  Iterator<Map.Entry<Integer,String>> it1 = entryset.iterator();
  while(it1.hasNext())
  {
   Map.Entry<Integer,String> me = it1.next();
   Integer key = me.getKey();
   String  values = me.getValue();
   System.out.println(key+"::"+values);
  }
 }
}

泛型：JDK1.5版本以后出现新特性。用于解决安全问题，是一个类型安全机制。
  好处：把运行时期出现的ClassCastException,转移到了编译时期，
    方便于程序员解决问题，让运行时 问题减少，安全。
    避免了强制转换的麻烦。
 
 泛型格式：通过<>定义需要操作的引用数据类型
  在使用java提供的对象时，什么时候使用泛型呢？
   通常在集合框架中很常见只要见到<>就要定义泛型，其实<>就是用来接受泛型的
   当时用集合时，将集合中需要存储的数据类型作为参数传递到<>中即可。
  示例：

 class GenericDemo 
  {
    public static void main(String[] args) 
   {
     ArrayList<String> al = new ArrayList<String>();//说明这个集合里面只能放String类型的元素。
     al.add("java01");
     al.add("java03");
     al.add("javasa03");
     //al.add(6)；集合里面只能装引用对象不能装变量。
     //al.add(3);类型转换异常，这个集合里面有两种类型的对象
 
    Iterator<String> it = al.iterator();
     while(it.hasNext())
     {
      //String s= (String)it.next();
      String s= it.next();//避免了强制转换，因为既然上面定义了String泛型，说明集合
           //里面装的都是String也就可以不用强制转换了
      System.out.println(s+"::"+s.length());
     }
    }
   }
 

   泛型类
   什么时候定义泛型类？
   当类中要操作的引用数据类型不确定的时候，早期定义Object来完成扩展。现在定义泛型来完成扩展。
 
  泛型类定义的泛型，在整个类中有效。如果被方法使用，那么泛型类的对象
   明确要操作的具体类型后，所有要操作的类型就已经固定了。
 
 泛型方法
   为了让不同方法可以操作不同类型，而且类型还不确定。那么可以将泛型定义在方法上。
  
   特殊之处：
   静态方法不可以访问类上定义的泛型。
   如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。
 
  示例：
 
  

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 GenericDemo 
  {
    public static void main(String[] args) 
   {
     Demo <String> d = new Demo<String>();
     d.show("haha");
     //d.show(4);
     d.print(5);
     d.print("hehe");
 
    Demo.method("hahahahha");
 
    /*
     Demo d = new Demo();
     d.show("haha");
     d.show(new Integer(4));
     d.print("heihei");
     */
     /*
     Demo<Integer> d = new Demo<Integer>();
 
    d.show(new Integer(4));
     d.print("hah");
 
    Demo<String> d1 = new Demo<String>();
     d1.print("haha");
     d1.show(5);
     */
    }
   }

 

 

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------