润清的博客

Appearance

集合 ​

集合框架 ​

集合框架大致可分为三层， 1.最上层是一组接口， 2.继而是接口的实现类， 3.接下来是针对集合各种操作的实现算法的工具类。

1.接口 ​

Collection：集合框架中最基本的接口，一个Collection存储一组无序，不唯一（可重复）的对象，一般不直接使用该接口。 List：Collection的子接口，存储一组有序，不唯一的对象，最常用的接口之一。 Set：Collection的子接口，存储一组无序，唯一（不可重复）的对象。 SortedSet：Set的子接口，可以对集合中的元素进行排序。

Map：独立于Collection的另外一个接口，存储一组键值对象，key-value的映射，无序，key唯一，value不唯一。 Map.Entry：Map的内部接口，描述Map中的一个键值对象。 SortedMap：Map的子接口，可以对集合中的键值对象进行排列。

Iterator：输出集合元素的接口，一般跟Set结合起来使用，适用于无序集合。 ListIterator：Iterator的子接口，可以双向输出集合中的元素。

Enumeration：早期的输出接口，已经被Iterator所取代。 Queue：队列接口，此接口的子类可以实现队列操作。

2.实现类 ​

a. Collection ​

常用方法 ​
Java
int size()：获取集合长度
boolean isEmpty()：判断集合是否为空
boolean contains(Object o)：判断集合中是否存在某个对象
Iterator<E> iterator()：实例化Iterator接口，遍历集合。
Object[] toArray()：将集合转换为一个Object类型的对象数组。
<T> T[] toArray(T[] a)：将集合转换为一个指定数据类型的对象数组。
boolean add(E e)：向集合中添加一个元素。
boolean remove(Object o)：从集合中移除元素。
booelan containsAll(Collection<> c)：判断集合中是否存在另外一个集合的所有元素。
boolean addAll(Collection<> c)：向集合中添加某个集合的所有元素
boolean removeAll(Collection<> c)：从集合中移除某个集合的所有元素
boolean removeIf(Predicate<> filter)：从集合中移除满足给定的集合所有元素
boolean retainAll(Collection<> c)：对集合进行操作，只保留包含在该集合中的元素
void clear()：清除集合中的所有元素
boolean equals(Collection<> c)：比较两个集合是否相等
int hashCode()：获取集合的哈希值。
Spliterator<E> spliterator()：将集合转换为一个指定的数据类型的并行迭代器。
Stream<E> stream()：将集合转换为一个流。
Stream<E> parallelStream()：将集合转为为一个可并行的流。

b. List ​

常用方法 ​
Java
List接口在继承Collection接口的基础上对方法进行了扩展，常用的扩展方法如下：
E get(int index)：通过下标获取集合中指定位置的元素，类似于数组中的array[0]，list.get(0);
E set(int index,E element)：替换集合中指定位置的元素。
void add(int index,E element)：向指定的位置添加（插入）元素。
E remove(int index)：通过下标删除集合中指定位置的元素。
int indexOf(Objec o)：查找某个对象在集合中的位置。
int lastIndexOf(Object o)：从后向前查找某个对象在集合中的位置。
ListIterator<E> listIterator()：实例化ListIterator接口。
List<E> subList(int fromIndex,int toIndex)：截取集合中的子集合

例子：sub的两种传参： [1,2,3,4,5,6,7] 1）

Java
sub(int fromIndex,int toIndex)
sub(3,4):[4]

2）

Java
sub(int fromIndex,int length)
sub(3,4):[4,5,6,7]
List接口的实现类 ​
  1. ArrayList ArrayList是开发中经常会用到的实现类，实现了长度可变的数组，在内存中分配连续的空间，底层是基于索引的数据结构，所以访问元素的效率较高，使用索引进行查询可以快速访问到对应的元素，缺点是添加或者删除元素比较麻烦，需要移动兄弟元素的位置，效率较低。
java
public class Test {
 public static void main(String[] args) {
     public static void ArrayListTest() {
            //实例化ArrayList对象
            ArrayList arrayList = new ArrayList();
            //向集合中顺序添加元素
            arrayList.add(1);
            arrayList.add("Hello");
            arrayList.add("World");
            // Array的toString方法是打印内存地址，ArrayList的父类AbstractCollection重写了toString方法
            System.out.println(arrayList); // [1, "Hello", "World"]

            ArrayList arrayList2 = new ArrayList();
            // 添加某个元素到集合末尾
            arrayList2.add(3.3f);
            arrayList2.addAll(arrayList);
            System.out.println(arrayList2); // [3.3, 1, "Hello", "World"]

            //向集合中的指定位置添加元素add(index, element)
            arrayList2.add(2, 2);
            // 判断是否为空
            System.out.println(arrayList2.isEmpty());
            System.out.println(arrayList2);
            //输出arrayList2的长度
            System.out.println(arrayList2.size());
            //判断arrayList2中是否包含"Java"
            System.out.println(arrayList2.contains("Java"));
            System.out.println("***********************************");
            //遍历集合
            //通过for循环来遍历
            for(int i = 0; i < arrayList2.size(); i++) {
                // get数组集合某个索引的值
                System.out.println(arrayList2.get(i));
            }
            System.out.println("**************************************");
            //通过foreach循环来遍历
            for(Object o:arrayList2) {
                System.out.println(o);
            }
            System.out.println("**************************************");
            //通过迭代器来遍历 Iterator
            Iterator iterator = arrayList2.iterator();
            while(iterator.hasNext()) {
                System.out.println(iterator.next());
            }
            System.out.println("**************************************");
            System.out.println(arrayList2);
            //替换集合中的元素
            arrayList2.set(3, 3);
            System.out.println(arrayList2);
            //查找元素在集合中的第一个下标
            // 从前向后查找
            System.out.println(arrayList2.indexOf("World"));
            System.out.println(arrayList2.indexOf(3));
            // 从后向前查找
            System.out.println(arrayList2.lastIndexOf(3));

            //remove(index)删除指定下标的某个元素，并返回删除元素。
            System.out.println(arrayList2.remove(3));
            System.out.println(arrayList2);
            // remove(element)删除指定某个元素，并返回boolean值表示是否成功删除。
            System.out.println(arrayList2.remove("World"));
            System.out.println(arrayList2);

            //截取下标1-3（不包括3）的子集合
            List arrayList3 = arrayList2.subList(1, 3);
            System.out.println(arrayList3);
        }
    }
}
  1. Vector Vector是List一个早期的实现类，用法基本和ArrayList一致。
java
public class Test {
 public static void main(String[] args) {
        public static void VectorTest() {
            Vector vector = new Vector();
            vector.add("Hello");
            // 同上
            vector.addElement("World");
            System.out.println(vector);

            // 判断是否为空
            System.out.println(vector.isEmpty());
            // 移除索引为0的元素
            vector.remove(0);
            vector.remove(0);
            System.out.println(vector.isEmpty());
        }
    }
}
  1. Stack Stack是Vector的一个子类，实现了一个“后进先出”的栈。
java
public class Test {
 public static void main(String[] args) {
        public static void StackTest() {
            Stack stack = new Stack();
            //添加元素
            stack.push("Hello");
            stack.push("JavaSE");
            stack.push("JavaME");
            stack.push("JavaEE");
            System.out.println(stack);
            //遍历
            for(int i = 0; i < stack.size(); i++) {
                System.out.println(stack.get(i));
            }
            //访问栈顶元素
            System.out.println("栈顶元素是："+stack.peek());
            System.out.println(stack);
            //取出栈顶元素
            System.out.println("栈顶元素是："+stack.pop());
            System.out.println(stack);
            System.out.println("栈顶元素是："+stack.pop());
            System.out.println(stack);
            System.out.println("栈顶元素是："+stack.pop());
            System.out.println(stack);
            System.out.println("栈顶元素是："+stack.pop());
            System.out.println(stack);
            System.out.println("栈顶元素是："+stack.pop());
            System.out.println(stack);
        }
    }
}
  1. LinkedList LinkedList是List的另外一个常用的实现类，与ArrayList不同，LinkedList实现了一个“先进先出”的队列，底层采用链表的形式存储，分散的内存空间，元素和元素之间通过存储彼此的位置信息来形成连接的逻辑关系，通过位置信息找到前后节点的关系。添加和删除元素的效率更高，因为只需要修改前后节点信息即可，缺点是查询效率不高，因为需要从第一个元素开始关联到被查询到元素。 LinkedList需要更多的存储空间，因为除了保存每个节点的数据之外，还需要保存前后节点的位置信息。
java
public class Test {
 public static void main(String[] args) {
        public static void LinkedListTest() {
  LinkedList linkedList = new LinkedList();
            linkedList.add("Hello");
            linkedList.add("World");
            linkedList.add("Java");
            System.out.println(linkedList); // ["Hello", "World", "Java"]
            //向集合的尾部添加元素
            linkedList.offer("SE");
            System.out.println(linkedList);
            //向集合的头部添加元素
            linkedList.offerFirst("ME");
            System.out.println(linkedList);
            //向集合的尾部添加元素
            linkedList.offerLast("EE");
            System.out.println(linkedList);
            //向集合的尾部添加元素
            linkedList.addLast("END");
            System.out.println(linkedList);
            //向集合的头部添加元素
            linkedList.push("First");
            System.out.println(linkedList);
            //向集合的头部添加元素
            linkedList.addFirst("0");
            System.out.println(linkedList);
            //访问队列的第一个元素
            System.out.println(linkedList.peek());
            System.out.println(linkedList);
            //取出队列的第一个元素
            System.out.println(linkedList.pop());
            System.out.println(linkedList);
            //访问队列的最后一个元素
            System.out.println(linkedList.peekLast());
            //访问队列的第一个元素
            System.out.println(linkedList.peekFirst());
            //取出队列的第一个元素
            System.out.println(linkedList.poll());
            System.out.println(linkedList);
            //取出队列的最后一个元素
            System.out.println(linkedList.pollLast());
            System.out.println(linkedList);
            //取出队列的第一个元素
            System.out.println(linkedList.pollFirst());
            System.out.println(linkedList);
            //取出队列的第一个元素
            System.out.println(linkedList.getFirst());
            //取出队列的最后一个元素
            System.out.println(linkedList.getLast());
            //取出指定位置的元素
            System.out.println(linkedList.get(2));
        }
    }
}

LinkedList和Stack都有pop方法，都是取出集合的第一个元素，但是其顺序是恰好相反的。 Stack采用的是“后进先出”的原则，是栈的形式，LinkedList采用的是“先进先出”的原则，是队列(Queue)的形式。 LinkedList定义时实现了Deque接口，Deque是Queue的子接口，Queue继承自Collection，底层实现了队列的数据结构。

在实际开发中，不能直接实例化Queue的对象来完成操作，需要实例化其实现类，Queue的实现类是AbstractQueue，AbstractQueue是一个抽象类，开发时需要对其子类进行实例化PriorityQueue进行实例化。

PriorityQueue使用时需要注意，添加到该队列的数据必须是有序，即对象具备排序的功能，自定义的类需要实现Comparable接口。

java
public class Test {
 public static void main(String[] args) {
        // 使用PriorityQueue
        PriorityQueue queue = new PriorityQueue();
        //创建User对象
  User user1 = new User(1,"张三");
  User user2 = new User(2,"李四");
  queue.add(user1);
  queue.add(user2);
  queue.add(null);
  System.out.println(queue);
    }
}
java
public class User implements Comparable{
 private int id;
 private String name;
 public int getId() {
  return id;
 }
 public void setId(int id) {
  this.id = id;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public User(int id, String name) {
  super();
  this.id = id;
  this.name = name;
 }
 /**
  * 对象的排序方法
  * A与B比较
  * A.compareTo(B)
  * 1:A>B
  * 0:A=B
  * -1:A<B
  */
 @Override
 public int compareTo(Object o) {
  // TODO Auto-generated method stub
  User user = (User) o;
  if(this.id > user.getId()) {
   return 1;
  }else if(this.id == user.getId()) {
   return 0;
  }else {
   return -1;
  }
 }
 @Override
 public String toString() {
  return "User [id=" + id + ", name=" + name + "]";
 }
}

  1. Set Set接口是Collection的子接口，Set接口采用的是散列的存储方式，所以集合中的元素没有顺序，Set可以存储一组无序，唯一（不可重复）的对象。 实际开发中不能直接实例化Set对象，需要对其实现类进行实例化操作完成业务代码，Set的常用的实现类有HashSet，LinkedHashSet，TreeSet。

    a. HashSet HashSet是开发中经常使用到的Set的实现类，存储一组无序，唯一(不可重复)的对象，这里的无序是指元素的存储顺序和遍历顺序是不一致的。 唯一的判断，在于存储对象的equals方法是否相等。

java
public class Test2 {
 public static void main(String[] args) {
        public static void HashSetTest() {
  HashSet hashSet = new HashSet();
  hashSet.add("Hello");
  hashSet.add("World");
  hashSet.add("Java");
  hashSet.add("JavaSE");
  hashSet.add("JavaME");
  hashSet.add("JavaEE");
  hashSet.add("Hello");
  System.out.println(hashSet);

  // (1)使用增强型for循环遍历集合
  for(Object obj:hashSet) {
   String str = (String) obj;
   System.out.println(str);
  }
  System.out.println("**************************");

  // (2)使用迭代器遍历集合
  Iterator iterator = hashSet.iterator();
  while(iterator.hasNext()) {
   String str = (String) iterator.next();
   System.out.println(str);
  }

  //获取hashset的长度
  System.out.println(hashSet.size());

  //删除元素，参数可传值或索引
  hashSet.remove("JavaSE");
  System.out.println(hashSet.size());
  
  HashSet hashSet2 = new HashSet();
        // 两个user对象是不同的，故都可以存进HashSet中。
  hashSet2.add(new User(1,"张三"));
  hashSet2.add(new User(1,"张三"));
  
  for(Object obj:hashSet2) {
   User user = (User) obj;
   System.out.println(user);
  }
 }
}
b. **LinkeHashSet**

LinkeHashSet是Set的另外一个子接口，可以存储一组有序，唯一的元素。这里的有序指元素的存储顺序和遍历顺序是一致的。

java
public class Test2 {
 public static void main(String[] args) {
        public static void LinkedHashSetTest() {
            LinkedHashSet set = new LinkedHashSet();
            set.add("Hello");
            set.add("World");
            set.add("Java");
            set.add("JavaSE");
            set.add("JavaME");
            set.add("JavaEE");
            set.add("Hello");
            Iterator iterator = set.iterator();
            while(iterator.hasNext()) {
                String str = (String)iterator.next();
                System.out.println(str);
            }

            System.out.println(set.size());
            set.remove("Hello");

            LinkedHashSet set2 = new LinkedHashSet();
            set2.add(new User(1,"张三"));
            set2.add(new User(1,"张三"));
            System.out.println(set2);
        }
    }
}

LinkedHashSet判断两个对象是否相等：

  1. 判断两个对象的hashCod（哈希值）是否相等。 hashCode？ 简单来说就是根据一定的规则讲与对象相关的信息，比如内存地址，属性值等，压缩成一个数值，这个数值称为散列值，就是改对象的hashCode。 两个不同对象的hashCode可能相等，但是hashCode值不相等的两个对象一定不是同一个对象。

  2. 如果两个对象的hashCode不相等，那么这两个对象肯定不是一个对象，集合中可以全部保存。 如果两个对象的hashCode相等，再通过equals方法来判断，如果equals为true，表示是同一个对象，不能重复添加，如果equals为false，不是同一个对象，可以重复添加。

先判断hashCode的作用是尽量减少对equals方法的调用，提高效率。

java
public class User implements Comparable{
 private int id;
 private String name;
 public int getId() {
  return id;
 }
 public void setId(int id) {
  this.id = id;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public User(int id, String name) {
  super();
  this.id = id;
  this.name = name;
 }
 
    //  ......

 @Override
 public int hashCode() {
  // 重写hashCode方法，return一个相同的值
  return 1;
 }
 @Override
 public boolean equals(Object obj) {
  // 重写equals方法
  return true;
 }

    // 这样实例化的不同对象，会被认为是相同的。
}

例1 ​

java
package com.southwind.test;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Scanner;

import com.southwind.entity.Dog;

public class Test3 {
 public static void main(String[] args) {
//  LinkedListTest();
  HashSetTest();
 }
 
 public static void ArrayListTest() {
  System.out.println("请输入4个Dog:");
  ArrayList list = new ArrayList();

  list.add(new Dog("旺财","黑背"));
  Dog newDog = new Dog("小黑","牧羊犬");
  list.add(newDog);
  list.add(new Dog("来福","拉布拉多"));
  Dog newDog2 = new Dog("大黄","藏獒");
  list.add(newDog2);

  System.out.println("共计"+list.size()+"条Dog");
  System.out.println("分别是：");
  for(int i = 0; i < list.size(); i++) {
   Dog dog = (Dog) list.get(i);
   System.out.println(dog.getName()+"\t\t"+dog.getBrand());
  }

  System.out.println("------操作------");

  System.out.println("删除集合中指定dog对象，小黑");
  list.remove(newDog);
  System.out.println("删除之后：");
  System.out.println("分别是：");
  for(int i = 0; i < list.size(); i++) {
   Dog dog = (Dog) list.get(i);
   System.out.println(dog.getName()+"\t\t"+dog.getBrand());
  }

  System.out.println("判断集合中是否包含大黄");
  boolean flag = list.contains(newDog2);
  if(flag) {
   System.out.println("集合中包含了大黄");
  }else {
   System.out.println("集合中没有大黄");
  }
 }
 
 public static void LinkedListTest() {
  System.out.println("请输入4个Dog:");
  LinkedList list = new LinkedList();

  list.add(new Dog("旺财","黑背"));
  Dog newDog = new Dog("小黑","牧羊犬");
  list.add(newDog);
  list.add(new Dog("来福","拉布拉多"));
  Dog newDog2 = new Dog("大黄","藏獒");

  list.add(newDog2);
  for(int i = 0; i < list.size(); i++) {
   Dog dog = (Dog) list.get(i);
   System.out.println(dog.getName()+"\t\t"+dog.getBrand());
  }

  System.out.println("集合的头部Dog：");
  Dog firstDog = (Dog) list.getFirst();
  System.out.println(firstDog.getName()+"\t\t"+firstDog.getBrand());

  System.out.println("集合的尾部Dog：");
  Dog lastDog = (Dog) list.getLast();
  System.out.println(lastDog.getName()+"\t\t"+lastDog.getBrand());

  System.out.println("向集合头部添加Dog");
  list.addFirst(new Dog("新新","斑点狗"));
  for(int i = 0; i < list.size(); i++) {
   Dog dog = (Dog) list.get(i);
   System.out.println(dog.getName()+"\t\t"+dog.getBrand());
  }

  System.out.println("向集合尾部添加Dog");
  list.addLast(new Dog("新新2","斑点狗"));
  for(int i = 0; i < list.size(); i++) {
   Dog dog = (Dog) list.get(i);
   System.out.println(dog.getName()+"\t\t"+dog.getBrand());
  }
  System.out.println("移除集合头部的Dog");
  list.removeFirst();
  for(int i = 0; i < list.size(); i++) {
   Dog dog = (Dog) list.get(i);
   System.out.println(dog.getName()+"\t\t"+dog.getBrand());
  }

  System.out.println("移除集合尾部的Dog");
  list.removeLast();
  for(int i = 0; i < list.size(); i++) {
   Dog dog = (Dog) list.get(i);
   System.out.println(dog.getName()+"\t\t"+dog.getBrand());
  }
 }
 
 public static void HashSetTest() {
        // 无序、唯一
  HashSet set = new HashSet();
  set.add(new Dog("旺财","黑背"));
  Dog newDog = new Dog("小黑","牧羊犬");
  set.add(newDog);
  set.add(new Dog("来福","拉布拉多"));
  Dog newDog2 = new Dog("大黄","藏獒");
  set.add(newDog2);
  System.out.println("共计"+set.size()+"条Dog");

  Iterator iterator = set.iterator();
  while(iterator.hasNext()) {
   Dog dog = (Dog) iterator.next();
   System.out.println(dog.getName()+"\t\t"+dog.getBrand());
  }
 }
}
java
package com.southwind.entity;

public class Dog {

  private String name;
  private String brand;

  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  public String getBrand() {
    return brand;
  }
  public void setBrand(String brand) {
    this.brand = brand;
  }
  public Dog(String name, String brand) {
    super();
    this.name = name;
    this.brand = brand;
  }
}

Map ​

List,Set是Collection的子接口，Map是完全独立于Collection另外一个接口框架。

Collection，List，Set接口都存储的是单值，Map每次存储一对对象，并且这对象满足key-value映射关系。 Map集合在创建时，必须指定key的数据类型以及value的数据类型。 Map集合可以存储一组无序，key值不可重复，value值可重复的对象。 例如：

Java
Student stu = new Student(1,"张三");
List.add(stu);
Map.put(1,stu);

Map定义时使用了泛型， List<E>Map<K, V>

E：Element元素，是指代保存到集合中的数据对象，Element/E本身不是一个Java类，只是具有指代意义的一个单词 K：Key键值对的键，指代保存到集合中的键元素 V：Value键值对的值，指代保存到集合中的值元素 T：Type类型，指代某个数据类型

Map常用方法 ​

java
1.public void clear() 清空Map集合

2.public boolean containsKey(Object key) 判断集合中是否存在key值

3.public boolean conatinsValue(Object value) 判断集合中是否存在value值

4.public Set<Map.Entry<K V>> entrySet() 取出Map集合中的Entry，转换成Set集合

5.public boolean equals(Object o) 判断两个集合是否相等

6.public V get(Object key)  根据key值获取对应的value

7.public int hashCode() 返回哈希值

8.public boolean isEmpty() 判断集合是否为空

9.public Set<K> keySet() 返回集合中的所有key值，封装到一个Set集合中

10.public Collection<V> values() 返回集合中的所有value值，封装到一个Collection集合中

11.public void putAll(Map<k V> m) 想集合中添加另外一个集合的所有元素

12.public V put(K key, V value) 向集合中添加元素（成对 key-value）

13.public V remove(Object key) 删除集合中的key，以及对应的value

14.public int size() 返回集合的长度

存：put(Object key,Object value) 取：get(Object key) 删：remove(Object key) 改：put(Object key,Object value) //key值已存在

Map.Entry是Map内部定义的一个接口，用来保存key-value映射的内容 ​

Map的常用子类 ​

HashMap：存储一组无序，key不可重复，value可重复的元素

Hashtable：存储一组无序，key不可重复的元素

TreeMap：可以排序的Map集合，按照key来排序，key不可重复

WeakHashMap：弱引用的Map集合

IdentityHashMap：key可以重复的集合

HashMap举例 ​

例1 ​
java
import java.util.HashMap;
import java.util.Map;

public class Test {
 public static void main(String[] args) {
  HashMap<Integer,String> hashMap = new HashMap();
  hashMap.put(1, "Java");
  hashMap.put(2, "Hello");
  hashMap.put(3, "World");
  for(int i = 1; i <= 3; i++) {
   System.out.println(hashMap.get(i));
  }
 }
}
例2 ​
java
import java.util.HashMap;
import java.util.Map;

public class Test {
 public static void main(String[] args) {
  HashMap<String,String> hashMap = new HashMap();
  hashMap.put("k1", "Java");
  hashMap.put("k2", "Hello");
  hashMap.put("k3", "World");
  hashMap.put("a", "Java");
  hashMap.put("v", "Hello");
  hashMap.put("c", "World");
  hashMap.put("99", "Java");
  hashMap.put("12", "Hello");
  hashMap.put("3", "World");

  // 输出全部key值
  Set keys = hashMap.keySet();
  System.out.println(keys);
  Iterator iter = keys.iterator();
  while(iter.hasNext()) {
   System.out.println(hashMap.get(iter.next()));
  }

  //输出全部values值
  Collection collection = hashMap.values();
  Iterator iter2 = collection.iterator();
  while(iter2.hasNext()) {
   System.out.println(iter2.next());
  }

  //判断hashMap中指定的key或者
  boolean flag = hashMap.containsKey("k1");
  if(flag) {
   System.out.println("hashMap中存在k1");
  }

  // 判断hashMap中value是否存在
  boolean flag2 = hashMap.containsValue("Html");
  if(flag2) {
   System.out.println("hashMap中存在html");
  }else {
   System.out.println("hashMap中不存在html");
  }
 }
}

Hashtable举例 ​

Vector：线程安全，安全性更高，性能较差 ArrayList：线程不安全，安全性较差，性能较高

Hashtable：线程安全，性能较差 HashMap：线程不安全，性能较高

java
import java.util.Hashtable;
import java.util.Map;

public class Test {
 public static void main(String[] args) {
  hashtableTest();
 }

 public static void hashtableTest() {
  Hashtable<String, String> hashtable = new Hashtable<String,String>();
  hashtable.put("k1", "Hello");
  hashtable.put("k2", "World");
  hashtable.put("k3", "Java");
  hashtable.put("k4", "Hello");
  hashtable.put("k5", "World");
  hashtable.put("k6", "Java");
  hashtable.put("k7", "Hello");
  hashtable.put("k8", "World");
  hashtable.put("k9", "Java");
  System.out.println(hashtable.keySet());
 }
}

TreeMap举例 ​

TreeMap可以按照key进行排序，根据key值对应的数值进行升序排序存储。 如果是一个自定义数据类型，则该类必须实现Comparable，并且实现compareTo方法，在该方法中自定义当前类对象的排序规则。

例1 ​
java
import java.util.TreeMap;
import java.util.Map;

public class Test {
 public static void main(String[] args) {
  treeMapTest();
 }

 public static void treeMapTest() {
  TreeMap<String,String> map = new TreeMap<String,String>();
  map.put("a", "Hello");
  map.put("b", "World");
  map.put("c", "Java");
  map.put("e", "JavaSE");
  map.put("f", "JavaME");
  map.put("d", "JavaEE");

  Set keys = map.keySet();
  Iterator iter = keys.iterator();
  while(iter.hasNext()) {
   String str = (String) iter.next();
   System.out.println(str+":"+map.get(str));
  }

  TreeMap<Integer,String> map2 = new TreeMap<Integer,String>();
  map2.put(3, "Java3");
  map2.put(1, "Java1");
  map2.put(5, "Java5");
  map2.put(4, "Java4");
  map2.put(6, "Java6");
  map2.put(2, "Java2");

  // 通过key遍历
  Set keys2 = map2.keySet();
  Iterator iter2 = keys2.iterator();
  while(iter2.hasNext()) {
   int key2 = (Integer) iter2.next();
   System.out.println(key2+":"+map.get(key));
  }

  // 通过Map.Entry遍历
  Set <Entry<Integer,String>> entry = map.entrySet();
  Iterator entryIterator = entry.iterator();
  while (entryIterator.hasNext()) {
   Entry<Integer, String> item = (Entry<Interger, String>) entryIterator.next();
   Integer key3 = item.getKey();
   String value3 = item.getValue();
   System.out.println(key3 + "-----" + value3);
  }

  // 增强型for循环
  for (Integer key4: keys) {
   String value4 = map.get(key);
   System.out.println(key4 + "-----" + value4);
  }

  //获取集合的第一个key值
  Integer firstKey = map.firstKey();
  System.out.println("集合的第一个key："+firstKey);
  //获取集合的第一个entry
  Entry<Integer,String> firstEntry = map.firstEntry();
  System.out.println("集合的第一个entry："+firstEntry+":"+firstEntry.getKey()+"---"+firstEntry.getValue());
  //获取集合的最后一个key值
  Integer lastKey = map.lastKey();
  System.out.println("集合的最后一个key："+lastKey);
  //获取集合的最后一个entry
  Entry<Integer,String> lastEntry = map.lastEntry();
  System.out.println("集合的最后一个entry："+lastEntry+":"+lastEntry.getKey()+"---"+lastEntry.getValue());
  //获取集合中key值大于3的最小key
  Integer higherKey = map.higherKey(3);
  System.out.println("集合中key值大于3的最小key："+higherKey);
  //获取集合中key值小于3的最大key
  Integer lowerKey = map.lowerKey(3);
  System.out.println("集合中key值小于3的最大key："+lowerKey);
  //获取集合中key值大于3的最小entry
  Entry<Integer,String> higherEntry = map.higherEntry(3);
  System.out.println("集合中key值大于3的最小entry："+higherEntry);
  //获取集合中key值小于3的最大entry
  Entry<Integer,String> lowerEntry = map.lowerEntry(3);
  System.out.println("集合中key值小于3的最大entry："+lowerEntry);
  //截取集合subMap(fromKey, toKey)，左闭右开
  SortedMap<Integer,String> map2 = map.subMap(3, 5);
  System.out.println(map2);
 }
}
例2 ​
java
public class User implements Comparable{
 private int id;
 private String name;
 public int getId() {
  return id;
 }
 public void setId(int id) {
  this.id = id;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public User(int id, String name) {
  super();
  this.id = id;
  this.name = name;
 }
 @Override
 public String toString() {
  return "User [id=" + id + ", name=" + name + "]";
 }
 @Override
 public int compareTo(Object o) {
  // TODO Auto-generated method stub
  User user = (User) o;
  if(this.id > user.getId()) {
   return 1;
  }else if(this.id == user.getId()) {
   return 0;
  }else {
   return -1;
  }
 }
}
java
import java.util.TreeMap;
import java.util.Map;

public class Test {
 public static void main(String[] args) {
  treeMapTest();
 }

 public static void treeMapTest() {
  TreeMap<User,String> map = new TreeMap<User,String>();
  map.put(new User(1,"张三"),"张三");
  map.put(new User(2,"李四"),"李四");
  map.put(new User(3,"王五"),"王五");
  Set keys = map.keySet();
  Iterator iter = keys.iterator();
  while(iter.hasNext()) {
   User user = (User) iter.next();
   System.out.println(user+":"+map.get(user));
  }
 }
}

WeakHashMap ​

java
import java.util.WeakHashMap;
import java.util.Map;

public class Test {
 public static void main(String[] args) {
  weakHashMapTest();
 }

 public static void weakHashMapTest() {
  WeakHashMap<String,String> map = new WeakHashMap<String,String>();
  map.put("a", "Java");
  map.put("b", "World");
  map.put("c", "Java");
  map.put("d", "JavaSE");
  map.put("e", "JavaME");
  map.put("f", "JavaEE");
  //强制执行一次垃圾回收
  System.gc();
  map.put("h", "HHH");
  System.out.println(map);
 }
}

Collections：集合的工具类 ​

Collections VS Collection ​

Collection是一个集合接口，用来存储数据的 Collections是一个集合的工具类，用来操作集合中的数据的

Collections常用方法 ​

java
1.public static <T> boolean add.All(Collection<T> c,Collection<T> c) //将一个集合添加到另外一个集合中

2.public static T max(Collection<T> c) //返回集合中的最大值

3.public static T min(Collection<T> c) //返回集合中的最小值

4.public static boolean replaceAll(List<T> list, T oldValue,T newVlaue) //将list集合中的oldValue全部替换为newValue

5.public static void reverse(List<T> list) //将集合中的元素反转

6.public static int binarySearch(List<T> list,T key) //查找集合中指定的元素

7.public static final List<T> emptyList() //清空List集合

8.public static final Map<K,V> emptyMap() //清空Map集合

9.public static final Set<T> emptySet() //清空Set集合

10.public static void sort(List<T> list) //对集合进行排序操作，规则根据T实现的ComparTo来决定

11.public static void swap(List<T> list,int i,int j) //交换指定位置的元素
java
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import com.southwind.entity.User;

public class Test {
 public static void main(String[] args) {
  /**
   * emptyList
   * emptySet
   * emptyMap
   * 获取不可变的集合
   * 
   */
  List listConst = Collections.emptyList();
  Set setConst = Collections.emptySet();
  Map mapConst = Collections.emptyMap();

  /**
   * addAll
   * 向集合添加元素，元素个数没有要求
   */
  ArrayList list = new ArrayList();
  list.add("Hello");
  list.add("World");
  System.out.println("添加之前："+list);
  Collections.addAll(list, "Java","JavaSE","JavaME");
  System.out.println("添加之后："+list);

  /**
   * reverse
   * 将集合中的元素进行反转
   */
  System.out.println("反转之前："+list);
  Collections.reverse(list);
  System.out.println("反转之后："+list);

  /**
   * binarySearch：集合中元素的数据类型要一致，集合中的元素按照升序进行排列
   * 检索元素在集合中的位置，若结果大于等于0则表示集合中存在该元素
   * 若结果小于0则表示集合中不存在该元素
   */
   int index = Collections.binarySearch(list, "World");
   System.out.println(index);

   /**
   * replaceAll(list, oldVal, newVal)
   * 替换集合中的内容
   */
  Collections.replaceAll(list, 1, 666);
  System.out.println(list);


  /**
   * swap
   * 交换指定位置的元素
   * 
   */
  System.out.println("交换之前："+list);
  Collections.swap(list, 1, 3);
  System.out.println("交换之后："+list);


  /**
   * sort(list[,comparator接口实现类])
   * 对集合进行排序
   */
  //  1.默认数据类型的排序
  ArrayList list2 = new ArrayList2();
  Collections.addAll(list2,3,5,1,4,6,2);
  System.out.println(list2);
  // 升序排列（默认使用元素的数据类型的编码进行排序）
  Collections.sort(list2);
  System.out.println(list2);
  // 降序排列
  Collections.reverse(list2);
  System.out.println(list2);


  // 2.自定义排序方法 ，使用单独定义的实现类来实例化接口
  MyCompartor mc = new MyCompartor();
  Collections.sort(list2,mc);

  // 3.自定义排序方法，直接new一个接口的代理对象，在定义中添加比较方法
  Collections.sort(list2, new Comparator() {

   @Override
   public int compare(Object o1, Object o2) {
    // TODO Auto-generated method stub
    int num1 = (int) o1;
    int num2 = (int) o2;
    if(num1 < num2) {
     return 1;
    }else if(num1 == num2) {
     return 0;
    }else {
     return -1;
    }
   }
  });
  System.out.println(list);

  // 4.对自定义数据类型的排序
  ArrayList list3 = new ArrayList();
  Collections.addAll(list3,new User(1,"张三",30),new User(2,"李四",26),new User(3,"王五",18));
  System.out.println(list3);
  Collections.sort(list3,new Comparator() {

   @Override
   public int compare(Object o1, Object o2) {
    // TODO Auto-generated method stub
    User user1 = (User) o1;
    User user2 = (User) o2;
    if(user1.getAge() > user2.getAge()) {
     return 1;
    }else if(user1.getAge() == user2.getAge()) {
     return 0;
    }else {
     return -1;
    }
   }
  });
  System.out.println(list3);
 }
}
java
package com.southwind.test;

import java.util.Comparator;

public class MyCompartor implements Comparator{

 @Override
 public int compare(Object o1, Object o2) {
  // TODO Auto-generated method stub
  int num1 = (int) o1;
  int num2 = (int) o2;
  /**
   * 升序排列
   */
//  if(num1 > num2) {
//   return 1;
//  }else if(num1 == num2) {
//   return 0;
//  }else {
//   return -1;
//  }
  /**
   * 降序排列
   */
  if(num1 < num2) {
   return 1;
  }else if(num1 == num2) {
   return 0;
  }else {
   return -1;
  }
 }

 public static int add(int... nums) {
  int result = 0;
  for(int num :nums) {
   result += num;
  }
  return result;
 }
}

集合的意义 ​

实际开发中，用集合来描述对象和对象之间的关系。

一对一：两个对象之间的关系是一对一，A中只能有一个B，B中只能有一个A。

人和身份证：一个人只能有一个身份证，一个身份证只能对应一个人。

一对多：两个对象之间的关系是一对多，A中只能有一个B，B中可以有多个A。

客户和订单：一个订单只能对应一个客户，一个客户可以对应多个订单。

多对多：两个对象之间的关系是多对多，A中可以有多个B，B中也可也有多个A。

学生和选课：一个学生可以选择多门课，一门课可以被多个学生选择。

java
package com.southwind.test;

import java.util.ArrayList;
import java.util.List;

import com.southwind.entity.Card;
import com.southwind.entity.Course;
import com.southwind.entity.Customer;
import com.southwind.entity.Order;
import com.southwind.entity.Person;
import com.southwind.entity.Student;

public class Test2 {
 public static void main(String[] args) {
  /**
   * 一对一
   */
  Person person = new Person();
  person.setName("张三");
  person.setAge(22);
  Card card = new Card();
  card.setId("12345678909876");
  card.setProvince("河北省");
  //建立person和card的关系
  person.setCard(card);
  card.setPerson(person);
//  System.out.println(person);
  System.out.println(card);
  
  /**
   * 一对多
   */
  Customer customer = new Customer();
  customer.setId(1);
  customer.setName("张三");
  
  Order order1 = new Order();
  order1.setId(1);
  order1.setName("订单1");
  order1.setCustomer(customer);

  Order order2 = new Order();
  order2.setId(2);
  order2.setName("订单2");
  order2.setCustomer(customer);
  
  List orders = new ArrayList();
  orders.add(order1);
  orders.add(order2);
  customer.setOrders(orders);
  
  System.out.println("order1的信息：");
  System.out.println(order1.getId());
  System.out.println(order1.getName());
  System.out.println(order1.getCustomer());
  
  System.out.println("order2的信息：");
  System.out.println(order2.getId());
  System.out.println(order2.getName());
  System.out.println(order2.getCustomer());
  
  System.out.println("customer的信息：");
  System.out.println(customer.getId());
  System.out.println(customer.getName());
  List list = customer.getOrders();
  for(int i = 0; i < list.size(); i++) {
   Order order = (Order) list.get(i);
   System.out.println(order);
  }
  
  /**
   * 多对多
   */
  //创建两个学生
  Student student1 = new Student();
  student1.setNum(1);
  student1.setName("张三");
  
  Student student2 = new Student();
  student2.setNum(2);
  student2.setName("李四");
  
  //创建三门课程
  Course course1 = new Course();
  course1.setId(1);
  course1.setName("数据结构与算法");
  
  Course course2 = new Course();
  course2.setId(2);
  course2.setName("Java高级编程");
  
  Course course3 = new Course();
  course3.setId(3);
  course3.setName("MySQL数据库");
  
  //学生选课，张三选了Java和MySQL
  //让学生来维护关系
  List courses = new ArrayList();
  courses.add(course2);
  courses.add(course3);
  
  student1.setCourses(courses);
  
  System.out.println("学生的选课信息");
  System.out.println("学生学号："+student1.getNum());
  System.out.println("学生姓名："+student1.getName());
  System.out.println("选课记录：");
  List list = student1.getCourses();
  for(Object obj:list) {
   Course course = (Course) obj;
   System.out.println("课程编号："+course.getId());
   System.out.println("课程名称："+course.getName());
  }
  
  System.out.println("************************************");
  
  //李四选择数据结构，Java，MySQL
  //让课程来维护关系
  List students = new ArrayList();
  students.add(student2);
  course1.setStudents(students);
  System.out.println("课程被选记录");
  System.out.println("课程信息");
  System.out.println("课程编号："+course1.getId());
  System.out.println("课程名称："+course1.getName());
  System.out.println("选择该课程的学生记录");
  List list2 = course1.getStudents();
  for(Object obj:list2) {
   Student student = (Student) obj;
   System.out.println("学生学号："+student.getNum());
   System.out.println("学生姓名："+student.getName());
  }
  System.out.println("-----------------------");
  List list3 = new ArrayList();
  list3.add(student1);
  list3.add(student2);
  course2.setStudents(list3);
  System.out.println("课程信息");
  System.out.println("课程编号："+course2.getId());
  System.out.println("课程名称："+course2.getName());
  System.out.println("选择该课程的学生记录");
  List list4 = course2.getStudents();
  for(Object obj:list4) {
   Student student = (Student) obj;
   System.out.println("学生学号："+student.getNum());
   System.out.println("学生姓名："+student.getName());
  }
  System.out.println("-----------------------");
  List list5 = new ArrayList();
  list5.add(student1);
  list5.add(student2);
  course3.setStudents(list5);
  System.out.println("课程信息");
  System.out.println("课程编号："+course3.getId());
  System.out.println("课程名称："+course3.getName());
  System.out.println("选择该课程的学生记录");
  List list6 = course3.getStudents();
  for(Object obj:list6) {
   Student student = (Student) obj;
   System.out.println("学生学号："+student.getNum());
   System.out.println("学生姓名："+student.getName());
  }
 }
}
java
public class Person {
 private String name;
 private int age;
 private Card card;
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public int getAge() {
  return age;
 }
 public void setAge(int age) {
  this.age = age;
 }
 public Card getCard() {
  return card;
 }
 public void setCard(Card card) {
  this.card = card;
 }
 @Override
 public String toString() {
  return "Person [name=" + name + ", age=" + age + "]";
 }
}
java
public class Card {
 private String id;
 private String province;
 private Person person;
 public String getId() {
  return id;
 }
 public void setId(String id) {
  this.id = id;
 }
 public String getProvince() {
  return province;
 }
 public void setProvince(String province) {
  this.province = province;
 }
 public Person getPerson() {
  return person;
 }
 public void setPerson(Person person) {
  this.person = person;
 }
 @Override
 public String toString() {
  return "Card [id=" + id + ", province=" + province + ", person=" + person + "]";
 }
 
}
java
import java.util.List;

public class Customer {
 private int id;
 private String name;
 private List orders;
 public int getId() {
  return id;
 }
 public void setId(int id) {
  this.id = id;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public List getOrders() {
  return orders;
 }
 public void setOrders(List orders) {
  this.orders = orders;
 }
 @Override
 public String toString() {
  return "Customer [id=" + id + ", name=" + name + "]";
 } 
}
java
public class Order {
 private int id;
 private String name;
 private Customer customer;
 public int getId() {
  return id;
 }
 public void setId(int id) {
  this.id = id;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public Customer getCustomer() {
  return customer;
 }
 public void setCustomer(Customer customer) {
  this.customer = customer;
 }
 @Override
 public String toString() {
  return "Order [id=" + id + ", name=" + name + "]";
 } 
}
java
import java.util.List;

public class Student {
 private int num;
 private String name;
 private List courses;
 public int getNum() {
  return num;
 }
 public void setNum(int num) {
  this.num = num;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public List getCourses() {
  return courses;
 }
 public void setCourses(List courses) {
  this.courses = courses;
 }
}
java
import java.util.List;

public class Course {
 private int id;
 private String name;
 private List students;
 public int getId() {
  return id;
 }
 public void setId(int id) {
  this.id = id;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public List getStudents() {
  return students;
 }
 public void setStudents(List students) {
  this.students = students;
 } 
}

泛型 ​

Generics：在类定义时不指定类中属性的具体的数据类型，由外部在声明和实例化对象时来指定属性的数据类型，也可以不指定，如果不指定，则任意的数据类型都可以赋给该属性，即该属性的数据类型成为了Object。

在类的定义时通过一个标识（T/type）来表示类中某个属性的数据类型或者某个方法的返回值类以及参数类型。在实例化该类对象时只需要指定具体的数据类型即可。

java
public class GUser<T> {
 private T name;

 public T getName() {
  return name;
 }

 public void setName(T name) {
  this.name = name;
 } 
}
java
import com.southwind.entity.GUser;

public class Test {
 public static void main(String[] args) {
  User user = new User();
  user.setName("张三");
  
  GUser<String> guser = new GUser<String>();
  guser.setName("李四");
  
  GUser<Integer> guser2 = new GUser<Integer>();
  guser2.setName(123);
}

使用泛型的好处 ​

java
public class Point {
 private Object x;
 private Object y;
 public Object getX() {
  return x;
 }
 public void setX(Object x) {
  this.x = x;
 }
 public Object getY() {
  return y;
 }
 public void setY(Object y) {
  this.y = y;
 }
}
java
public class GPoint<T> {
 private T x;
 private T y;
 public T getX() {
  return x;
 }
 public void setX(T x) {
  this.x = x;
 }
 public T getY() {
  return y;
 }
 public void setY(T y) {
  this.y = y;
 }
}
java
import com.southwind.entity.GPoint;
import com.southwind.entity.Point;

public class PointTest {
 public static void main(String[] args) {
  // 不使用泛型
  test1();
  // 使用泛型
  test2();
 }
 
 public static void test() {
  //使用整数类型的坐标
  Point p1 = new Point();
  p1.setX(10);//int---Integer---Object
  p1.setY(20);//Object---Integer---int
  int x = (int) p1.getX();

  //使用小数类型的坐标
  Point p2 = new Point();
  p2.setX(3.5);//double---Double---Object
  double x2 = (double) p2.getX();//Object---Double---double

  //使用String类型的坐标
  Point p3 = new Point();
  p3.setX("东经60度");//String---Object
  String x3 = (String) p3.getX();//Object---String
 }
 
 public static void test2() {
  //使用整数类型
  GPoint<Integer> p1 = new GPoint<Integer>();
  p1.setX(10);//不需要数据类型转换，提高效率，节省空间和时间
  int x = p1.getX();
  //使用小数类型
  GPoint<Double> p2 = new GPoint<Double>();
  p2.setX(3.5);//不需要数据类型转换，提高效率，节省空间和时间
  double x2 = p2.getX();
  //使用整数类型
  GPoint<String> p3 = new GPoint<String>();
  p3.setX("东经60度");//不需要数据类型转换，提高效率，节省空间和时间
  String x3 = p3.getX();
 }
}

类中的泛型可以同时指定多个，用来标识不同的属性，例如Map<K,V>

java
public class GMap<K,V> {
 private K key;
 private V value;
 public K getKey() {
  return key;
 }
 public void setKey(K key) {
  this.key = key;
 }
 public V getValue() {
  return value;
 }
 public void setValue(V value) {
  this.value = value;
 }
}
java
import com.southwind.entity.GMap;

public class Test {
 public static void main(String[] args) {
  GMap<String,String> map = new GMap<String,String>();
  map.setKey("a");
  map.setValue("A");

  GMap<Integer,String> map2 = new GMap<Integer,String>();
  map2.setKey(1);
  map2.setValue("A");
 }
}

泛型的通配符?表示可以接收此类型的任意泛型对象。泛型里不能使用多态，只能使用通配符。

java
import com.southwind.entity.GUser;

public class Test {
 public static void main(String[] args) {
  GUser<String> guser = new GUser<String>();
  guser.setName("李四");
  test(guser);
  
  GUser<Integer> guser2 = new GUser<Integer>();
  guser2.setName(123);
  test(guser2);
 }

 // ? 表示可以接收此类型的任意泛型对象
 public static void test(GUser<?> user) {
  System.out.println(user.getName());
 }
}

受限泛型 实际开发中，操作泛型时可以设置一个泛型对象的范围上限和下限。 范围上限使用extends关键字声明，表示实例化时指定的类型是泛型类型的子类或者泛型类型。 范围下限使用super关键字来声明，表示实例化时指定的类型是泛型类型的父类或者泛型类型。

1）泛型的上限 extends ​

例如：一个方法中只能接收数值类型的数据（byte（Byte），int（Integer），short（Short），long（Long），double（Double），float（Float）），在定义泛型时就可以指定其上限。

java
// 只能是数值类型
public class Cal<T extends Number> {
 private T num;

 public T getNum() {
  return num;
 }

 public void setNum(T num) {
  this.num = num;
 }
 
}
java
import com.southwind.entity.Cal;

public class Test {
 public static void main(String[] args) {
  Cal<Double> cal = new Cal<Double>();
 }
}
2）泛型的下限 super ​
java
public static void test(GUser<? super String> user) {//只能接收String或者Object类型的参数
 System.out.println(user.getName()); 
}

包装类 ​

包装类是Java提供的一组类，专门用来描述8种基本数据类型，包装类一共包括8种，这些类都保存在java.lang包中。

基本数据类型包装类
byteByte
shortShort
intInteger
longLong
floatFloat
doubleDouble
charCharacter
booleanBoolean

装箱和拆箱 ​

装箱是指将基本数据类型转为对应的包装类。 拆箱是指将包装类转为对应的基本数据类型。

装箱 ​

1.public Type(type value) 每一个包装类都提供了一个带参的构造函数用来实例化包装类对象。

2.public Type(String value)/public Type(char value) Boolean类型的构造函数，当参数为“true”时，Boolean的值为true，参数为除“true”以外的任意值时，结果都为false

3.vauleOf(type value) 每一个包装类都有一个静态的vauleOf方法，可以将基本数据类型转为包装类类型

4.vauleOf(String value)/valueOf(char value) vauleOf方法有重载，可以将String类型/char类型转为包装类类型 Boolean类型的构造函数，当参数为“true”时，Boolean的值为true，参数为除“true”以外的任意值时，结果都为false

java
package com.southwind.test;

public class PackageTest {
 public static void main(String[] args) {
  // 1.使用public Type(type value)
  byte b = 1;
  Byte byt = new Byte(b);
  short s = 2;
  Short shor = new Short(s);
  int i = 3;
  Integer integer = new Integer(i);
  long l = 4l;
  Long lon = new Long(l);
  float f = 5.5f;
  Float flo = new Float(f);
  double d = 6.6;
  Double dou = new Double(d);
  char cha = 'J';
  Character charac = new Character(cha);
  boolean bo = true;
  Boolean bool = new Boolean(bo);
 }
}
java
package com.southwind.test;

public class PackageTest {
 public static void main(String[] args) {
  // 2.使用public Type(String value)/public Type(char value)
  Byte byt = new Byte("1");
  Short shor = new Short("2");
  Integer integer = new Integer("3");
  Long lon = new Long("4");
  Float flo = new Float("5.5f");
  Double dou = new Double("6.6");
  // public Type(char value)
  Character charac = new Character('J');
  // Boolean类型的构造函数，当参数为“true”时，Boolean的值为true，参数为除“true”以外的任意值时，结果都为false
  Boolean bool = new Boolean("abc"); // false
  System.out.println(byt+1);
  System.out.println(bool);
 }
}
java
package com.southwind.test;

public class PackageTest {
 public static void main(String[] args) {
  // 3.使用vauleOf(type value)
  byte b = 1;
  Byte byt = Byte.valueOf(b);
  short s = 2;
  Short shor = Short.valueOf(s);
  int i = 3;
  Integer integer = Integer.valueOf(i);
  long l = 4l;
  Long lon = Long.valueOf(l);
  float f = 5.5f;
  Float flo = Float.valueOf(f);
  double d = 6.6;
  Double dou = Double.valueOf(d);
  char cha = 'J';
  Character charac = Character.valueOf(cha);
  boolean bo = true;
  Boolean bool = Boolean.valueOf(bo);
 }
}
java
package com.southwind.test;

public class PackageTest {
 public static void main(String[] args) {
  // 4.使用vauleOf(String value)/valueOf(char value)
  Byte byt = Byte.valueOf("1");
  Short shor = Short.valueOf("2");
  Integer integer = Integer.valueOf("3");
  Long lon = Long.valueOf("4");
  Float flo = Float.valueOf("5.5f");
  Double dou = Double.valueOf("6.6");
  // valueOf(char value)，Character类型使用char而不是string
  Character charac = Character.valueOf('J');
  // Boolean类型的构造函数，当参数为“true”时，Boolean的值为true，参数为除“true”以外的任意值时，结果都为false
  Boolean bool = Boolean.valueOf("true");
 }
}
拆箱 ​

1.typeVaule() 每一个包装类都有一个typeValue()方法，type为包装类对应的基本数据类型名，通过该方法可以将包装类转为基本数据类型。

2.parseType(String value) Type为包装类的类名 除了Character类以外的每一个包装类都有一个静态方法可以将字符串类型的数据转为对应的基本数据类型。 Boolean.parseBoolean(String value)，value="true",Boolean值为true,否则都为false

java
package com.southwind.test;

public class PackageTest {
 public static void main(String[] args) {
  // 1.使用typeVaule()
  Byte byt = Byte.valueOf("1");
  Short shor = Short.valueOf("2");
  Integer integer = Integer.valueOf("3");
  Long lon = Long.valueOf("4");
  Float flo = Float.valueOf("5.5f");
  Double dou = Double.valueOf("6.6");
  Character charac = Character.valueOf('J');
  Boolean bool = Boolean.valueOf("true");
  
  byte b = byt.byteValue();
  short s = shor.shortValue();
  int i = integer.intValue();
  long l = lon.longValue();
  float f = flo.floatValue();
  double d = dou.doubleValue();
  char c = charac.charValue();
  boolean b = bool.booleanValue();
 }
}
java
package com.southwind.test;

public class PackageTest {
 public static void main(String[] args) {
  // 2.使用parseType(String value)
  byte b = Byte.parseByte("1");
  short s = Short.parseShort("2");
  int i = Integer.parseInt("3");
  long l = Long.parseLong("4");
  float f = Float.parseFloat("5.5f");
  double d = Double.parseDouble("6.6");
  boolean bo = Boolean.parseBoolean("true");
 }
}
其他方法 ​

toString(type value) 每一个包装类都有一个静态方法toString，该方法可以将基本数据类型转为String类型。

java
package com.southwind.test;

public class PackageTest {
 public static void main(String[] args) {
  byte b = 1;
  String bstr = Byte.toString(b);
  short s = 2;
  String sstr = Short.toString(s);
  int i = 3;
  String istr = Integer.toString(i);
  long l = 4l;
  String lstr = Long.toString(l);
  float f = 5.5f;
  String fstr = Float.toString(f);
  double d = 6.6;
  String dstr = Double.toString(d);
  char c = 'J';
  String cstr = Character.toString(c);
  boolean bo = true;
  String bostr = Boolean.toString(bo);
 }
}