Java的框架学习笔记
2016-12-14 本文已影响39人
宝塔山上的猫
在java中Collection以及Map集合框架起着很大的作用，它是用于存储数据的一个框架，更多的理论知识可以查看Thinking in java这本书。
其中集合分为两大类，Collection和Map，其中Collection可以直接存储数据，而Map则是使用key-value的方式来存取数据的。
Collection框架
Collection是一个接口类，它底下有两个小弟，List和Set
Collection
|--List:元素是有序的，元素可以重复。因为该集合体系有索引。
|--ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。
|--LinkedList:底层使用的链表数据结构。特点：增删速度很快，查询稍慢。线程不同步。
|--Vector:底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。枚举是Vector特有的取出方式（nextElement()）（因名称及方法名过长，最终被迭代器取代）
|--Set：元素是无序(存入和取出的顺序不一定一致)，元素不可以重复。、
|--HashSet:底层数据结构是哈希表。是线程不安全的。不同步。
HashSet是如何保证元素唯一性的呢？
是通过元素的两个方法，hashCode和equals来完成。
如果元素的HashCode值相同，才会判断equals是否为true。
如果元素的hashcode值不同，不会调用equals。
注意,对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。
因为hashCode不同，所以有可能在HashSet中存入相同对象（属性相同，但是是new出来的）
|--TreeSet：可以对Set集合中的元素进行排序。
底层数据结构是二叉树。
保证元素唯一性的依据：
compareTo方法return 0.
TreeSet排序的第一种方式：让元素自身具备比较性。
元素需要实现Comparable接口，覆盖compareTo方法。
这种方式也称为元素的自然顺序，或者叫做默认顺序。
TreeSet的第二种排序方式。
当元素自身不具备比较性时，或者具备的比较性不是所需要的。
这时就需要让集合自身具备比较性。
在集合初始化时，就有了比较方式。
Set集合的功能和Collection是一致的。
上面就是Collection的组成，那么Collection是父类，就应该有一些公共的方法是大家都拥有的，以下是Collection以及它的子类所拥有的方法：
Collection定义了集合框架的共性功能。
1，添加
add(e);
addAll(collection);
2，删除
remove(e);
removeAll(collection);
clear();
3，判断。
contains(e);
isEmpty();
4，获取
iterator();
size();
5，获取交集。
retainAll();
6，集合变数组。
toArray();
1，add方法的参数类型是Object。以便于接收任意类型对象。
2，集合中存储的都是对象的引用(地址)
什么是迭代器呢？
其实就是集合的取出元素的方式。
迭代器是取出方式，会直接访问集合中的元素。
所以将迭代器通过内部类的形式来进行描述。
通过容器的iterator()方法获取该内部类的对象。
这些方法都可以在List和Set中能够使用。
需要特别注意的是迭代器Iterator的使用，其使用方法如下：
ArrayList al = new ArrayList();
// 1，添加元素。
al.add("java01");// add(Object obj);
al.add("java02");
al.add("java03");
al.add("java04");
/*
* Iterator it = al.iterator();//获取迭代器，用于取出集合中的元素。
*
* while(it.hasNext()) { sop(it.next()); }
*/
for (Iterator it = al.iterator(); it.hasNext();) {
sop(it.next());
}
List集合
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的子接口。
在迭代时，不可以通过集合对象的方法操作集合中的元素。
因为会发生ConcurrentModificationException异常。
所以，在迭代器时，只能用迭代器的方法操作元素，可是Iterator方法是有限的，
只能对元素进行判断，取出，删除的操作，
如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator。
该接口只能通过List集合的listIterator方法获取。
ArrayList集合
数组集合，常见的一种是用方式。
在容器中，判断对象是否相同是调用Object中的equals()方法，也就是只有保存同一个对象才是相同的。这就导致了如果你新建了一个对象的实例，而实例中的内容是相同的，调用equals的时候也会被判断为不同。
所以如果要依据对象的内容判断对象是否相同，则需要在对象内部重新equals()方法。
示例如下：
class Person {
private String name;
private int age;
Person(String name, int age) {
this.name = name;
this.age = age;
}
// 重写Object的equals方法
public boolean equals(Object obj) {
if (!(obj instanceof Person))
return false;
Person p = (Person) obj;
// System.out.println(this.name+"....."+p.name);
// 通过判断姓名和年龄是否相同来判断是否同一个Person
return this.name.equals(p.name) && this.age == p.age;
}
/**/
public String getName() {
return name;
}
public int getAge() {
return age;
}
}
class ArrayListTest2 {
public static void sop(Object obj) {
System.out.println(obj);
}
public static void main(String[] args) {
ArrayList al = new ArrayList();
al.add(new Person("lisi01", 30));// al.add(Object obj);//Object obj =
// new Person("lisi01",30);
// al.add(new Person("lisi02",32));
al.add(new Person("lisi02", 32));
al.add(new Person("lisi04", 35));
al.add(new Person("lisi03", 33));
// al.add(new Person("lisi04",35));
// al = singleElement(al);
sop("remove 03 :" + al.remove(new Person("lisi03", 33)));// remove方法底层也是依赖于元素的equals方法。
Iterator it = al.iterator();
while (it.hasNext()) {
// Object obj=it.next();//迭代器只能识别Object
// Person p=Person（obj);
Person p = (Person) it.next();
sop(p.getName() + "::" + p.getAge());
}
}
public static ArrayList singleElement(ArrayList al) {
// 定义一个临时容器。
ArrayList newAl = new ArrayList();
Iterator it = al.iterator();
while (it.hasNext()) {
Object obj = it.next();
if (!newAl.contains(obj))// 底层是依赖于元素的equals方法。
newAl.add(obj);
}
return newAl;
}
}
LinkedList集合
LinkedList:特有方法：
堆栈：先进后出 使用addFirst();
队列：先进先出
addFirst();
addLast();
getFirst();
getLast();
获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException
removeFirst();
removeLast();
获取元素，但是元素被删除。如果集合中没有元素，会出现NoSuchElementException
在JDK1.6出现了替代方法。
offerFirst();
offerLast();
peekFirst();
peekLast();
获取元素，但不删除元素。如果集合中没有元素，会返回null。
pollFirst();
pollLast();
获取元素，但是元素被删除。如果集合中没有元素，会返回null。
Vector集合
枚举就是Vector特有的取出方式。
发现枚举和迭代器很像。
其实枚举和迭代是一样的。
因为枚举的名称以及方法的名称都过长。
所以被迭代器取代了。
枚举郁郁而终了。
代码示例：
class VectorDemo {
public static void main(String[] args) {
Vector v = new Vector();
v.add("java01");
v.add("java02");
v.add("java03");
v.add("java04");
Enumeration en = v.elements();
while (en.hasMoreElements()) {
System.out.println(en.nextElement());
}
}
}
Set集合
HashSet集合
Set集合是无序的，并且元素不能相同。但在实际操作过程成如果在ArrayList中的示例一样，创建两个具有相同内容的Person对象存入，却仍旧能保存进去，这是因为对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。因为hashCode不同，所以有可能在HashSet中存入相同对象（属性相同，但是是new出来的）。
所以在保存对象的时候需要重写元素的hashcode和equals方法。
示例代码如下：
//先比较hash表中的对象地址值（HashCode值）如果地址值相同
//再通过equals（）方法比较对象内容,如果地址值不同，
//不需要调用equals比较内容
class HashSetTest {
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("a2",12));
// hs.add(new Person("a4",14));
// sop("a1:"+hs.contains(new Person("a2",12)));
// hs.remove(new Person("a4",13));
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 * 37;
}
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集合会对元素进行排序，因此在使用TreeSet的时候要让元素具有比较性，所以元素需要实现Comparable接口，覆盖compareTo方法。同时在排序时，当主要条件相同时，一定判断一下次要条件，否则会误判为是相同对象而不被保存。
示例代码：
class TreeSetDemo {
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("lisi007",20));
// ts.add(new Student("lisi01",40));
Iterator it = ts.iterator();
while (it.hasNext()) {
Student stu = (Student) it.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) {
// return 0;
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;
}
}
当元素自身不具备比较性，或者具备的比较性不是所需要的(元素是其他人写的，自己不能实现)。
这时需要让容器自身具备比较性。
定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。
当两种排序都存在时，以比较器为主。
定义一个类，实现Comparator接口，覆盖compare方法。
String类 ： int compareTo(String anotherString)按字典顺序比较两个字符串
Comparable 接口：int compareTo(T o) 比较此对象与指定对象的顺序。
返回：负整数、零或正整数，根据此对象是小于、等于还是大于指定对象
Comparator 接口：int compare（T o1, T o2）方法比较用来排序的两个参数，
返回：根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数。
示例代码如下(让学生对象从按照年龄排序转为按照姓名排序)：
// Strudent对象没有变化
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) {
// return 0;
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;
}
}
class TreeSetDemo2 {
public static void main(String[] args) {
// 使用自定义的Compare方法
TreeSet ts = new TreeSet(new MyCompare());
ts.add(new Student("lisi02", 22));
ts.add(new Student("lisi02", 21));
ts.add(new Student("lisi007", 20));
ts.add(new Student("lisi09", 19));
ts.add(new Student("lisi06", 18));
ts.add(new Student("lisi06", 18));
ts.add(new Student("lisi007", 29));
// ts.add(new Student("lisi007",20));
// ts.add(new Student("lisi01",40));
Iterator it = ts.iterator();
while (it.hasNext()) {
Student stu = (Student) it.next();
System.out.println(stu.getName() + "..." + stu.getAge());
}
}
}
// 实现Comparator接口，覆盖compare方法
class MyCompare implements Comparator {
public int compare(Object o1, Object o2) {
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()));
/*
* if(s1.getAge()>s2.getAge()) return 1;
* if(s1.getAge()==s2.getAge()) return 0; return -1;
*/
}
return num;
}
}
Map集合框架
Map与Collection框架在外部并没有什么必然的联系，但是其内部却稍微有些联系，因为Map集合也可以保持List集合。
当数据之间存在这映射关系时，就要先想map集合。
Map集合：该集合存储键值对。一对一对往里存。而且要保证键的唯一性。
1，添加。
put(K key, V value)
putAll(Map<? extends K,? extends V> m)
2，删除。
clear()
remove(Object key)
3，判断。
containsValue(Object value)
containsKey(Object key)
isEmpty()
4，获取。
get(Object key)
size()
values()
entrySet()
keySet()
Map
|--Hashtable:底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。jdk1.0.效率低。
|--HashMap：底层是哈希表数据结构，允许使用 null 值和 null 键，该集合是不同步的。将hashtable替代，jdk1.2.效率高。
|--TreeMap：底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序。
和Set很像。
其实大家，Set底层就是使用了Map集合。
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集合取出元素示例代码如下：
class MapDemo2 {
public static void main(String[] args) {
Map<String, String> map = new HashMap<String, String>();
map.put("02", "zhangsan2");
map.put("03", "zhangsan3");
map.put("01", "zhangsan1");
map.put("04", "zhangsan4");
// 将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> me = it.next();
String key = me.getKey();
String value = me.getValue();
System.out.println(key + ":" + value);
}
/*
//先获取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);
}
*/
}
}
集合中的工具类
Collections:集合框架的工具类。里面定义的都是静态方法。
Collections和Collection有什么区别？
Collection是集合框架中的一个顶层接口，它里面定义了单列集合的共性方法。
它有两个常用的子接口，
List：对元素都有定义索引。有序的。可以重复元素。
Set：不可以重复元素。无序。
Collections是集合框架中的一个工具类。该类中的方法都是静态的
提供的方法中有可以对list集合进行排序，二分查找等方法。
通常常用的集合都是线程不安全的。因为要提高效率。
如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的。
Collections的使用：
class CollectionsDemo {
public static void main(String[] args) {
sortDemo();
}
public static void binarySearchDemo() {
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
list.add("qq");
list.add("z");
// 排序
Collections.sort(list, new StrLenComparator());
sop(list);
// int index = Collections.binarySearch(list,"aaaa");
// int index = halfSearch(list,"cc");
int index = halfSearch2(list, "aaaa", new StrLenComparator());
sop("index=" + index);
}
public static int halfSearch(List<String> list, String key) {
int max, min, mid;
max = list.size() - 1;
min = 0;
while (min <= max) {
mid = (max + min) >> 1;// /2;
String str = list.get(mid);
int num = str.compareTo(key);
if (num > 0)
max = mid - 1;
else if (num < 0)
min = mid + 1;
else
return mid;
}
return -min - 1;
}
public static int halfSearch2(List<String> list, String key, Comparator<String> cmp) {
int max, min, mid;
max = list.size() - 1;
min = 0;
while (min <= max) {
mid = (max + min) >> 1;// /2;
String str = list.get(mid);
int num = cmp.compare(str, key);
if (num > 0)
max = mid - 1;
else if (num < 0)
min = mid + 1;
else
return mid;
}
return -min - 1;
}
public static void maxDemo() {
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
list.add("qq");
list.add("z");
Collections.sort(list);
sop(list);
String max = Collections.max(list/* ,new StrLenComparator() */);
sop("max=" + max);
}
public static void sortDemo() {
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
list.add("qq");
list.add("z");
sop(list);
// Collections.sort(list);
Collections.sort(list, new StrLenComparator());
// 互换
// Collections.swap(list,1,2);
sop(list);
}
public static void sop(Object obj) {
System.out.println(obj);
}
}
class StrLenComparator implements Comparator<String> {
public int compare(String s1, String s2) {
if (s1.length() > s2.length())
return 1;
if (s1.length() < s2.length())
return -1;
return s1.compareTo(s2);
}
}
集合变数组
Collection接口中的toArray方法。
示例代码如下：
class CollectionToArray {
public static void main(String[] args) {
ArrayList<String> al = new ArrayList<String>();
al.add("abc1");
al.add("abc2");
al.add("abc3");
/*
* 1,指定类型的数组到底要定义多长呢？ 当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。
* 当指定类型的数组长度大于了集合的size，就不会新创建了数组。而是使用传递进来的数组。 所以创建一个刚刚好的数组最优。
*
*
* 2,为什么要将集合变数组？ 为了限定对元素的操作。不需要进行增删了。
*
*/
String[] arr = al.toArray(new String[al.size()]);
System.out.println(Arrays.toString(arr));
}
}
关于Arrays
Arrays:用于操作数组的工具类，里面都是静态方法。
asList:将数组变成list集合
使用示例代码：
class ArraysDemo {
public static void main(String[] args) {
// int[] arr = {2,4,5};
//
// System.out.println(Arrays.toString(arr));
String[] arr = { "abc", "cc", "kkkk" };
// 把数组变成list集合有什么好处？
/*
* 可以使用集合的思想和方法来操作数组中的元素。 例如：当查找数组中的某一元素时直接用集合方便
* 注意：将数组变成集合，不可以使用集合的增删方法。 因为数组的长度是固定。 contains。 get indexOf()
* subList();
*
* 如果你增删。那么会反生UnsupportedOperationException,
*
*/
List<String> list = Arrays.asList(arr);
// sop("contains:"+list.contains("cc"));
// list.add("qq");//UnsupportedOperationException,
// sop(list);
// int[] nums = {2,4,5};
Integer[] nums = { 2, 4, 5 };
List<Integer> li = Arrays.asList(nums);
/*
* 如果数组中的元素都是对象。那么变成集合时，数组中的元素就直接转成集合中的元素。
* 如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。
*/
sop(li);
}
public static boolean myContains(String[] arr, String key) {
for (int x = 0; x < arr.length; x++) {
if (arr[x].equals(key))
return true;
}
return false;
}
public static void sop(Object obj) {
System.out.println(obj);
}
}
