黑马程序员-学习日记9（集合框架 2 ）

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

 

/*
枚举就是Vector特有的取出方式。
另外它还有迭代器、遍历get方法,按角标索引
发现枚举和迭代器很像。
其实枚举和迭代是一样的，为什么要有迭代呢？因为枚举的名
称以及方法的名称都过长，枚举郁郁而终了。IO中有一个对象用到了。
Vector支持枚举，iterator没有。
import java.util.*;
class VectorDemo{
 public static void main(String args[]){
  Vector vec = new Vector();
  vec.add("java01");
  vec.add("java02");
  vec.add("java03");
  vec.add("java04");
  Enumeration en = vec.elements();
  while(en.hasMoreElements()){
   System.out.println(en.nextElement());
  }

 }
}

 

 

LinkedList:特有方法
 addFirst();
 addLast();
 getFirst();返回此列表的第一个元素。
 getLast();如果集合中没有元素，会出现NoSushElementsException
 获取元素，但不删除元素。

 
 removeFirst();//如果集合中没有元素，会出现NoSushElementsException
 removeLast();移除并返回此列表的第一个元素。 获取元素，但元素被删除了。
 
 
 JDK1.6版本！！！
 offerFirst();//add换了
 offerLast();
 pollFirst 获取并移除此列表的第一个元素，如果此列表为空，则返回null；
 pollLast():

 peekFirst();
 peekLast();获取元素，但不删除元素，如果集合中没有元素，会返回NUll；

import java.util.*;
class VectorDemo{
 public static void main(String args[]){
  LinkedList link = new LinkedList();
  link.addFirst("java01");
  link.addFirst("java02");
  link.addFirst("java03");
  sop(link);
 } link.addFirst("java04");
 
 public static void sop(Object obj){
  System.out.println(obj);
 }
}

import java.util.*;
class VectorDemo{
 public static void main(String args[]){
  LinkedList link = new LinkedList();
  link.addLast("java01");
  link.addLast("java02");
  link.addLast("java03");
  link.addLast("java04");
  //sop(link);
  sop(link.getFirst());
  sop(link.getLast());
  sop(link.size());

 }
 public static void sop(Object obj){
  System.out.println(obj);
 }
}

import java.util.*;
class VectorDemo{
 public static void main(String args[]){
  LinkedList link = new LinkedList();
  link.addLast("java01");
  link.addLast("java02");
  link.addLast("java03");
  link.addLast("java04");
  while(!link.isEmpty()){
   sop(link.removeFirst());
  }
  sop("=========");
  while(!link.isEmpty()){
   sop(link.removeLast());
  }

 }
 public static void sop(Object obj){
  System.out.println(obj);
 }
}

 

//链表也是不同步的！！！！！！！！！！
import java.util.*;
class VectorDemo{
 public static void main(String args[]){
  LinkedList link = new LinkedList();
  link.addLast("java01");
  link.addLast("java02");
  link.addLast("java03");
  link.addLast("java04");
  while(!link.isEmpty()){
   sop(link.removeLast());
  }
 }
 public static void sop(Object obj){
  System.out.println(obj);
 }
}

//////////////////////////////////////////////////////////////////////////////
使用LinkedList模拟一个堆栈或者队列数据结构。
堆栈：先进后出
队列：先进先出

import java.util.*;
class DuiLie{
 private LinkedList link;
 DuiLie(){
  link = new LinkedList();
 }
 public void myAdd(Object obj){
  link.addFirst(obj);
 }
 public Object myGet(){
  return link.removeLast();
 }
 public boolean isNull(){
  return link.isEmpty();
 }
}

class VectorDemo{
 public static void main(String args[]){
  DuiLie d1 = new DuiLie();
  d1.myAdd("java01");
  d1.myAdd("java02");
  d1.myAdd("java03");
  d1.myAdd("java04");
  while(!d1.isNull()){
   System.out.println(d1.myGet());
  }
 }
 public static void sop(Object obj){
  System.out.println(obj);
 }
}

 

import java.util.*;
class DuiLie{
 private LinkedList link;
 DuiLie(){
  link = new LinkedList();
 }
 public void myAdd(Object obj){
  link.addFirst(obj);
 }
 public Object myGet(){
  return link.removeLast();
 }
 public boolean isNull(){
  return link.isEmpty();
 }
}

class VectorDemo{
 public static void main(String args[]){
  DuiLie d1 = new DuiLie();
  d1.myAdd("java01");
  d1.myAdd("java02");
  d1.myAdd("java03");
  d1.myAdd("java04");
  //while(!d1.isNull()){
   System.out.println(d1.myGet());
  //}
 }
 public static void sop(Object obj){
  System.out.println(obj);
 }
}

 

//去掉ArrayList中的重复元素。
import java.util.*;
class VectorDemo{
 public static void main(String ars[]){
  ArrayList a1 = new ArrayList();
  a1.add("java01");
  a1.add("java02");
  a1.add("java01");
  a1.add("java03");
  a1.add("java01");
  a1.add("java04");
  sop(a1);
  a1 = singleElement(a1);
  sop(a1);
  
 }
 public static void sop(Object obj){
  System.out.println(obj);
 }
 public static ArrayList singleElement(ArrayList a1){
  ArrayList newA1 = new ArrayList();
  sop(newA1.isEmpty());//这个集合为空。
  Iterator it = a1.iterator();
  while(it.hasNext()){
   Object obj = it.next();
   if(!newA1.contains(obj))
    newA1.add(obj);
  }
  return newA1;
 }
}

 

import java.util.*;
class VectorDemo{
 public static void main(String ars[]){
  ArrayList a1 = new ArrayList();
  a1.add("java01");
  a1.add("java02");
  a1.add("java01");
  a1.add("java03");
  a1.add("java01");
  //a1.add("java04");//NoSuchElementException此句
  
  Iterator it = a1.iterator();
  //在迭代时循环next调用一次，就要hasNext判断一次。
  //否则有可能报异常。
  while(it.hasNext()){
   sop(it.next()+"..."+it.next());//因为取了两个次，判一次。
  }
  
 }
 public static void sop(Object obj){
  System.out.println(obj);
 }
 public static ArrayList singleElement(ArrayList a1){
  ArrayList newA1 = new ArrayList();
  sop(newA1.isEmpty());//这个集合为空。
  Iterator it = a1.iterator();
  while(it.hasNext()){
   Object obj = it.next();
   if(!newA1.contains(obj))
    newA1.add(obj);
  }
  return newA1;
 }
}

 

////////////////////////

将自定义对象作为元素存到ArrayList集合中，并去除重复元素。
比如：存入对象，同姓同年龄，视为同一个人，为重复元素。
List 集合判断元素是否相同，依据的是元素的equals方法。
public boolean contains(Object o)如果此列表中包含指定的元素
则返回 true。更确切地讲，当且仅当此列表包含至少一个满足
(o==null ? e==null : o.equals(e)) 的元素 e 时，则返回 true。

public boolean remove(Object o)移除此列表中首次出现的指定
元素（如果存在）。如果列表不包含此元素，则列表不做改动。
更确切地讲，移除满足
(o==null ? get(i)==null : o.equals(get(i))) 的最低索引的
元素（如果存在此类元素）。如果列表中包含指定的元素，则返回
true（或者等同于这种情况：如果列表由于调用而发生更改，则返
回 true）。
///////////////////////////

 

import java.util.*;
class Person{
 private String name;
 private int age;
 Person(String name,int age){
  this.name = name;
  this.age = age;
 }
 public String getName(){
  return name;
 }
 public int getAge(){
  return age;
 }
}
class VectorDemo{
 public static void main(String ars[]){
  ArrayList a1 = new ArrayList();
//a1.add(Object obj);Object obj = new Person("lisi01",33);默认为它。
  a1.add(new Person("lisi01",30));
  a1.add(new Person("lisi02",32));
  a1.add(new Person("lisi03",33));
  a1.add(new Person("lisi04",35));
  Iterator i = a1.iterator();
  while(i.hasNext()){
   Person p =(Object)i.next();
   //多态编译失败。因为返回的Object,里面没有这方法
   //sop(i.next().getName()+".."+i.next().getAge());
   sop(p.getName()+"..."+p.getAge());

  }
 }
 public static void sop(Object obj){
  System.out.println(obj);
 }
 
 public static ArrayList singleElement(ArrayList a1){
  ArrayList newA1 = new ArrayList();
  Iterator it = a1.iterator();
  while(it.hasNext()){
   Object obj = it.next();
   if(!newA1.contains(obj))
    newA1.add(obj);
  }
  return newA1;
 }

}
 

 

//在ArrayList中判断元素是否相同用的是equals方法。
//Object中判断的是对象地址值是否相同!!!!!
import java.util.*;
class Person{
 private String name;
 private int age;
 Person(String name,int age){
  this.name = name;
  this.age = age;
 }
 public String getName(){
  return name;
 }
 public int getAge(){
  return age;
 }
 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;
 }
}

class VectorDemo{
 public static void main(String ars[]){
  ArrayList a1 = new ArrayList();
  a1.add(new Person("lisi01",30));//a1.add(Object obj);Object obj = new Person("lisi01",33);默认为它。
  //a1.add(new Person("lisi02",32));
  a1.add(new Person("lisi02",32));
  a1.add(new Person("lisi03",33));
  //a1.add(new Person("lisi04",35));
  //a1.add(new Person("lisi04",35));
  //a1.remove(new Person("lisi04",35));//删除上一个元素，当没有覆写父类中的equals的方法时。
  a1 = singleElement(a1);
  Iterator i = a1.iterator();
  while(i.hasNext()){
   Object obj = i.next();
   Person p = (Person)obj;
   //Person p = (Person)i.next();
   sop(p.getName()+".."+p.getAge());
  }
 }
 public static void sop(Object obj){
  System.out.println(obj);
 }
 
 public static ArrayList singleElement(ArrayList a1){
  ArrayList newA1 = new ArrayList();
  Iterator it = a1.iterator();
  while(it.hasNext()){
   Object obj = it.next();
   if(!newA1.contains(obj))
    newA1.add(obj);
  }
  return newA1;
 }
}

 

 

/////////////////////////////////////////////////////////////////////////////////////

Collection ：集合是可变长度的！！！
 |--List:元素是有序的，元素可以重复，因为该集合体系有索引。
  |--ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快，但增删稍慢，是线程不同步的效率高，默认数据长度为10，当超过长度为10的元素后，再往里增加的话，它会买new一个新的数组长度为原来的50%延长把原来数组的元素copy到新数组中来再把新元素增加到后面去。判断元素是否存在及删除元素，只依赖equals。原因在于数据结构不同，方法不同。而HashSet先依赖HashCode后依赖equals.
  |--LinkedList:底层使用的链表数据结构，特点：增删速度很快，查询稍慢。
  |--Vector:底层是数组数据结构。和ArrayList功能一模一样,是线程同步的，判锁，无论增删查都慢，被ArrayList替代了。
 |--Set:元素是无序的（存入和取出不一至），元素可以重复
   Set集合的功能和Collection是一致的。
     |--HashSet:底层数据结构是哈希表。哈希表是按照哈希值来存的，所以存入和取出时不一致。（因为每个字符串都有一个地址值，是按地址值存入的，，是线程非同步的。
     //HashSet是如何保证元素唯一性呢？是通过元素的两个方法，hashCode和equals来完成的，如果元素的HashCode值相同，才会判断equals是否为true
     //如果元素的hashCode值不同，不会调用equals方法。 所以当我们在自定义对象时，通常要覆写HashCode和equals方法。这两个方法是系统底层自己调用的。
     //对于判断元素是否存在，及删除等操作，依赖的方法是元素的hashcode和equals方法。
     //（先看哈希值）在哈希表中当哈希值重复的时候，它还有一次校验方式，（判断两个元素是否相同。）如果不同会要该哈希值下顺沿。
  |--TreeSet:可以对Set集合中的元素进行排序。按ASCII码排序。

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

为什么Add(),方法返回的是布尔型？当存入一个数据后，
因地址和内容一样是同一个元素，所以返回false.所以
添加失败为假。
false.

//往hashSet集合中存入自定义对象。姓名年龄相同为同人，重复元素。

 

import java.util.*;
class VectorDemo{
 public static void sop(Object obj){
  System.out.println(obj);
 }
 public static void main(String args[]){
  HashSet hs = new HashSet();
  hs.add(new Person("a1",11));
  hs.add(new Person("a2",12));
  hs.add(new Person("a3",13));
  //hs.add(new Person("a4",14));
  hs.add(new Person("a2",12));

  Iterator it = hs.iterator();
  while(it.hasNext()){
   Person p = (Person)it.next();
   sop(p.getName()+"..."+p.getAge());
  }
 }
}
class Person{
 private String name;
 private int age;
 Person(String name,int age){
  this.name = name;
  this.age = age;
 }
 public int hashCode(){
  System.out.println(this.name+"....hashCode");
  return name.hashCode()+age;
 }
 public boolean equals(Object obj){
  if(!(obj instanceof Person))
   return false;
  Person p = (Person)obj;
  System.out.println(this.name+"...equals..."+p.name);
  return this.name.equals(p.name)&&this.age==p.age;
 }
 public String getName(){
  return name;
 }
 public int getAge(){
  return age;
 }
}

 

往TreeSet集合中存储自定义对象学生。
想按学生的年龄进行排序。
TreeSet的要求是：往里面存的元素必须具备比较性。（实现Comparable接口)

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

import java.util.*;
class VectorDemo{
 public static void main(String args[]){
  TreeSet ts = new TreeSet();
  ts.add(new Student("lisi02",22));
  ts.add(new Student("lisi007",20));
  ts.add(new Student("lisi09",19));
  ts.add(new Student("lisi08",19));
  //ts.add(new Student("lisi01",40));
  Iterator i = ts.iterator();
  while(i.hasNext()){
   //System.out.println(i.next());
   Student stu = (Student)i.next();
   System.out.println(stu.getName()+"..."+stu.getAge());
  }
 }
}
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;
  System.out.println(this.name+"..compareto.."+s.name);
  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;
 }
}*/