黑马程序员--Java集合

-------Android培训、Java培训、期待与您交流！ ----------

Java集合：

 

数组与集合：

在创建Java数组时,数组的长度必要要指定.数组一旦创建好之后,长度不能改变.在同一个数组种只能存放同一种类型的数据(基本类型和引用类型)
为了使程序能方便的存储和操作数目不固定的一组数据,JDK类库种提供了Java集合.所有的Java集合都在java.util包中.在集合中,只能存放对象的引用,而不能存放基本数据类型

 

Java集合的3种类型：

 

Set(集):集合中的对象无排列顺序,并且没有重复的对象.它的有些实现类能对集合中的对象按照特定的方式进行排序
List(队列):集合中的对象按照索引的顺序排列,可以有重复的对象;
   可以按照对象在集合中的索引位置检索对象.List与数组有些相似
Map(映射):集合中的每一个元素都是一对一对的,包括一个key对象,一个Value对象(一个Key指向一个Value).集合中没有重复的key对象,但是vaulue对象可以重复.它的有些实现类能对集合怀中的键对象进行排序

Collection接口和Iterator接口

在Collection接口中声明了适合的Java集合(List和Set)适合的方法

方法                                                      描述
boolean add(Object obj)          向集合中添加一个对象
void clear()                                 删除集合中所有的对象
boolean contains(Object o)      判断在集合中是否包含特定的对象的引用
boolean isEmpty()                      判断集合是否为空
Iterator  iterator()                       返回一个Iterator类型的对象,用它来遍历集合
boolean remove(Object o)       从集合中删除一个对象
int size()                                    返回集合中元素的数量
Object[] toArray()                     返回一个对象的数组,该数组中包含集合中所有的元素

 Iterator接口封装了底层的数据结构,向用户提供了统一遍历集合的
     方法,在Iterator接口中声明了如下的方法

方法                                       描述
boolean hasNext()  判断集合中是否还有下一个元素
Object next()             返回下一个元素
void remove()        从集合中删除一个由next()方法返回的元素

Collection练习：

public static void main(String[] args) {CollectionTest test = new CollectionTest();Set set = new HashSet();set.add("Three");test.print(set);                                 Map map = new HashMap();map.put("M", "男");map.put("F", "女");System.out.println(map);}public void print(Collection coll) {Iterator iter = coll.iterator();while (iter.hasNext()) {System.out.println(iter.next());}}

如果集合中的元素 没有排序,Iterator遍历集合取出来的元 素的顺序也是无序 的.并不一定与加入 元素的顺序一致

 

Set：

Set集合中的对象不按照特定的方式排序,并且没有重复的对象?

HashSet类按照哈希算法来存取集合中的对象,速度较快

LinkedHashSet类不仅实现了哈希算法,而且实现了链表的数据结构,提高了插入和删除的功能

TreeSet类实现了SortedSet接口,具有排序的功能

Set的一般用法：

Set中存放的是对象的引用,并且没有重复的对象.

 String s1 = "Hello"; String s2 = s1; String s3 = "World";                Set set = new HashSet(); set.add(s1); set.add(s2); set.add(s3);                    System.out.println(set.size());

Set的add()方法会用equals方法()判断新加入的对象是否存在与集合之中如果equals方法返回true,add()方法就不会将其加入到Set中.从而保证了在Set中没有重复的对象.

String s1 = "Hello"; String s2 = s1;String s3 = "World"; String s4 = "World";Set set = new HashSet();set.add(s1); set.add(s2); set.add(s3); set.add(s4);System.out.println(set.size() + " " + set);

 

HashSet类

HastSet的add方法在对象加入的适合,不光会调用equals()方法判断对象是否相同,而且还调用hashCode方法进一步判断对象是否相同
如果在Student类中只覆盖了equals()方法,而没有覆盖hashCode()方法,会导致HashSet工作不正常.所以在自定义的类中,如果覆盖了equals()方法,最好也要覆盖hashCode()方法

import java.util.*;public class HashSetTest {public static void main(String[] args) {Student stu1 = new Student("张一", 6);Student stu2 = new Student("张一", 6);System.out.println(stu1.equals(stu2));Set set = new HashSet();set.add(stu1);set.add(stu2);System.out.println(set.size() + "  " + set );}}

 

TreeSet：

TreeSet类实现了SortedSet接口,能够对集合中的对象进行排序

Set set = new TreeSet();     set.add(new Integer(3)); set.add(new Integer(2));           set.add(new Integer(1)); set.add(new Integer(5));     Iterator it = set.iterator();     while (it.hasNext()) System.out.println(it.next());

 

import java.util.*;public class TreeSetTest {public static void main(String args[]) {Set set = new TreeSet();set.add(new Integer(3));set.add(new Integer(2));set.add(new Integer(1));set.add(new Integer(5));Iterator it = set.iterator();while (it.hasNext()) {Object obj = it.next();System.out.println(obj);}}}

 

TreeSet的排序方式：

向TreeSet中加入一个对象时.TreeSet会进行排序:
一部分类实现Comparable接口,如String,Integer,Double等. Comparable有个int compareTo() 方法
 对于表达式: x. compareTo(y),如果返回值为0 ,表示x,y相等;如果返回值大于0,表示x大于y;如果返回值小于0,表示x小于y.
 TreeSet真是调用对象的compareTo方法来比较对象的,然后进行升序排列在使用自然排序时,只能向TreeSet集合中加入同类型的对象,并且这些类必须实现Comparable接口

 

自定义类型与TreeSet：

如果自己定义的类要添加到TreeSet中，要实现Comparable接口，并实现该接口唯一的public int compareTo(Object o)方法；

public int compareTo(Object o) {Student stu = (Student) o;if (this.getName().compareTo(stu.getName()) > 0) return 1;if (this.getName().compareTo(stu.getName()) < 0) return -1;if ( this.age > stu.getAge() )  return 1;if (this.age < stu.getAge()) return -1;return 0;}

 

import java.util.*;public class TreeSetTest {public static void main(String args[]) {Set set = new TreeSet();Student stu1 = new Student("EEE", 12);Student stu2 = new Student("FFF", 11);Student stu3 = new Student("DDD", 13);set.add(stu1);set.add(stu2);set.add(stu3);Iterator it = set.iterator();while (it.hasNext()) {Object obj = it.next();System.out.println(obj);}}}

 

public class Student implements Comparable {private int age;private String name;public int getAge() {return age;}public void setAge(int age) {this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public Student() {}public Student(String name, int age) {this.name = name;this.age = age;}public boolean equals(Object obj) {boolean rusult = false;if (this == obj) {rusult = true;}if (!(obj instanceof Student)) {rusult = false;}Student stu = (Student) obj;if ((stu.getName().equals(this.name)) && (stu.getAge() == this.age)) {rusult = true;} else {rusult = false;}return rusult;}public int hashCode() {return (this.name.hashCode() + this.age) * 31;}public String toString() {return "name=" + this.name + " age=" + this.age;}public int compareTo(Object o) {Student stu = (Student) o;if (this.getName().compareTo(stu.getName()) > 0) {return 1;}if (this.getName().compareTo(stu.getName()) < 0) {return -1;}if ( this.age > stu.getAge() ) {return 1;}if (this.age < stu.getAge()) {return -1;}return 0;}}

 

List（列表）：

List主要特征是其元素以线型方式存储，集合中可以存放重复的对象
List的主要实现类包括：
ArrayList：代表长度可变的数组。可以对元素快速的随机访问。但是向ArratList插入或删除元素的速度较慢
LinkedList:在实现中才用了链表的数据接口，对顺序访问进行了优化。向List中插入和删除数据的速度快，随即访问的速度较慢。
访问列表的元素：

public static void main(String[] args) {List<Integer> list = new ArrayList<Integer>();Integer a = new Integer(2);Integer b = new Integer(3);Integer c = new Integer(4);Integer d = new Integer(2);list.add(a); list.add(b); list.add(c); list.add(d);// 也可以使用Iterator接口的方法遍历列表元素for (int i = 0; i < list.size(); i++) {     Object o = list.get(i);     System.out.println(o);}}

 

为列表排序;

如果要对List中的元素进行排序,可以借组Collections类,该类提供了操作集合的各种静态方法,其中sort()方法用于对List中的元素进行排序
     例如
  list.add(a);
  list.add(b);
  list.add(c);
  list.add(d);

  Collections.sort(list);

 

ListIterator接口和LinkedList类:

List的ListIterator()方法返回一个ListIterator类型的对象,

方法名称                    作用
add()             向列表中插入有个元素
hasNext()     判断列表中是否还有下一个元素
hasPrevious()  判断列表中是否还有上一个元素
next()              返回列表的下一个元素
previous()      返回列表的上一个元素

import java.util.*;public class LinkedListAndListIterator {public static void main(String[] args) {List<Integer> list = new LinkedList<Integer>();list.add(new Integer(3));list.add(new Integer(6));list.add(new Integer(5));list.add(new Integer(7));insert(list, 4);Collections.sort(list);System.out.println(list);}public static void insert(List<Integer> list, int data) {ListIterator<Integer> it = list.listIterator();while (it.hasNext()) {Integer in = it.next();if (data <= in.intValue()) {it.previous();it.add(new Integer(data));break;}}}}

 

固定长度的List:

Java.util.Arrays了的asList()方法可以将一个java数组包装成一个List对象,这个List对象的长度是固定的.对这个List不能调用List的add()方法和remove()方法,否则会抛出UnsupportedOperationException异常
例如:
      public static void main(String[] args) {
  String[] ss = { "aaa", "ccc", "ddd", "eee" };
  List<String> list = Arrays.asList(ss);
  list.set(0, "xxx");
  System.out.println(list);
  
  //list.add("fff");
 }

import java.util.*;public class 固定长度的List {public static void main(String[] args) {String[] ss = { "aaa", "ccc", "ddd", "eee" };List<String> list = Arrays.asList(ss);list.set(0, "xxx");System.out.println(list);list.add("fff");}}

 

比较数组和各种List:

对java数组随机访问和迭代操作的速度最快
LinkedList进行插入和删除速度最快
ArrayList进行随机访问的速度较快

Map:

Map是一种把键对象和值对象进行映射的集合,他的每一个元素都包含一个键对象,一个值对象,键对象相当于值对象的索引,而且值对象仍然可以是Map类型的
向Map中插入数据的时候,必须提供一对键对象和值对象.在取出Map元素的时候,通过get(Object key)可以取出对应的值对象
      Map<String ,String> map = new HashMap<String ,String>();
 map.put("1","AAA");
 String str = map.get(“1”); // str的值是AAA
Map中key对象要求不能重复,但是Value对象的值可以重复.而且后加入的值会覆盖原来的值
      Map<String ,String> map = new HashMap<String ,String>();
 map.put("1","AAA");
 map.put("1","BBB");
 map.put("1","CCC");
     String str = map.get(“1”); // str的值是CCC

 

集合的编译时类型检查:

在JDK1.5之前,集合中所有的元素的类型都是Object类型.在从集合中取出数据的时候,要进行相应的类型转换.由于有时类型部匹配,可能造成类型转换异常
      private static void addElements() {
  List list = new ArrayList();
  list.add("AAA");
  list.add(new StringBuffer("BBB"));
  print(list);
 }
 private static void print(List list) {
  for (int i = 0; i < list.size(); i++) {
   String str = (String) list.get(i);
   System.out.println(str);
  }
 }

 

JDK1.5集合新特性:

按照程序中错误的发现时间,错误可以分为两类
     1.  编译时错误
     2.   运行时错误
为了把一些在运行时的错误转换为编译时的错误,在JDK1.5中,引入了范性的概念,能够把运行时的ClassCastException 转换为编译时的类型不匹配错误
所谓的范型,是之集合中元素的类型.在声明集合变量和创建集合对象的时候用“< >”在指明元素的类型.如果在添加元素的时候,元素不是指定的类型,编译器会把错误检查出来
   Set <String> set = new HashSet<String>();
   set.add("AAA");
   set.add(new StringBuffer("BBB"));

范型例子:

import java.util.*;public class Test {/** * @param args */public static void main(String[] args) {createSet();}private static void createSet(){Set <String> set = new HashSet<String>();set.add("AAA");set.add("BBB");print(set);}private static void print(Set<String> set){Iterator<String> it = set.iterator();while(it.hasNext()){String str = it.next();System.out.println(str);}}}

用for循环遍历集合:

在JDK1.5之前,可以使用Iterator遍历集合
      public static void print(Set<String> set) {
  Iterator<String> it = set.iterator();
  while (it.hasNext()) {
   String str = it.next();
   System.out.println(str);
  }
 }
从JDK1.5开始,为遍历集合提供了更加简单的方法
      public static void print(Set<String> set) {
  // 从Set集合中依次取出每个String类型的元素,
                // 变量elements引用当前元素
  for (String elements : set) {
       System.out.println(elements);
  }
 }

 

 

实用集合类Collections:

在JDK中提供了操作数组的java.util.Arrays类,为操作java数组提供了一系列的静态方法
在JDK中,提供了java.util.Collections 类,可以用于操作List类型的集合,也可以用于操作所有的Collection类型或Map类型的集合
Collections类以下的方法使用与操作List类型的集合,
方法名称                                            用途
copy(List dest,List src)   将所有元素从一个列表复制到另一个列表
fill(List list,Object obj)     使用指定元素替换指定列表中的所有元素
sort(List list)                     对List中的元素进行自然升序排序
…….. 

import java.util.*;public class Test {/** * @param args */public static void main(String[] args) {List<String> list = createList();printList(list);list = sortList(list);printList(list);//// List<String> list1 = copy(list);// printList(list1);}public static List<String> createList() {List<String> list = new ArrayList<String>();list.add("SSS");list.add("BBB");list.add("FFF");return list;}public static List<String> copy(List<String> list) {List<String> newList = new ArrayList<String>();newList.add("111");newList.add("222");newList.add("333");newList.add("444");Collections.copy(newList, list);return newList;}public static List<String> fillList(List<String> list) {Collections.fill(list, "wwww");return list;}public static List<String> sortList(List<String> list) {Collections.sort(list);return list;}public static void printList(List<String> list) {for (String emlemetns : list) {System.out.println(emlemetns);}}}

 

Properties类:

InputStream in = getClass().getClassLoader().getResourceAsStream("DbInof.properties");if (in == null) {System.out.println("没有找到属性文件");return;}Properties pro = new Properties();try {     pro.load(in);} catch (IOException e) {     e.printStackTrace();}String Driver = pro.getProperty("dirver");String url = pro.getProperty("url");String user = pro.getProperty("user");String psw = pro.getProperty("psw");