我家有只小熊二
我家有只小熊二

【转】Java集合类: Set、List、Map、Queue使用场景梳理

转载出处：https://www.cnblogs.com/LittleHann/p/3690187.html

本文主要关注Java编程中涉及到的各种集合类，以及它们的使用场景

目录

1. Java集合类基本概念
2. Java集合类架构层次关系
3. Java集合类的应用场景代码

1. Java集合类基本概念

在编程中，常常需要集中存放多个数据。从传统意义上讲，数组是我们的一个很好的选择，前提是我们事先已经明确知道我们将要保存的对象的数量。一旦在数组初始化时指定了这个数组长度，这个数组长度就是不可变的，如果我们需要保存一个可以动态增长的数据(在编译时无法确定具体的数量)，java的集合类就是一个很好的设计方案了。

集合类主要负责保存、盛装其他数据，因此集合类也被称为容器类。所以的集合类都位于java.util包下，后来为了处理多线程环境下的并发安全问题，java5还在java.util.concurrent包下提供了一些多线程支持的集合类。

在学习Java中的集合类的API、编程原理的时候，我们一定要明白，”集合”是一个很古老的数学概念，它远远早于Java的出现。从数学概念的角度来理解集合能帮助我们更好的理解编程中什么时候该使用什么类型的集合类。

Java容器类类库的用途是”保存对象”，并将其划分为两个不同的概念：

1) Collection
一组"对立"的元素，通常这些元素都服从某种规则
 　　1.1) List必须保持元素特定的顺序
 　　1.2) Set不能有重复元素
 　　1.3) Queue保持一个队列(先进先出)的顺序
2) Map
一组成对的"键值对"对象

Collection和Map的区别在于容器中每个位置保存的元素个数:

1) Collection 每个位置只能保存一个元素(对象)
2) Map保存的是"键值对"，就像一个小型数据库。我们可以通过"键"找到该键对应的"值"

2. Java集合类架构层次关系

1. Interface Iterable

迭代器接口，这是Collection类的父接口。实现这个Iterable接口的对象允许使用foreach进行遍历，也就是说，所有的Collection集合对象都具有”foreach可遍历性”。这个Iterable接口只有一个方法: iterator()。它返回一个代表当前集合对象的泛型迭代器，用于之后的遍历操作。

1.1 Collection

Collection是最基本的集合接口，一个Collection代表一组Object的集合，这些Object被称作Collection的元素。
Collection是一个接口，用以提供规范定义，不能被实例化使用。

1) Set

Set集合类似于一个罐子，”丢进”Set集合里的多个对象之间没有明显的顺序。Set继承自Collection接口，不能包含有重复元素(记住，这是整个Set类层次的共有属性)。

Set判断两个对象相同不是使用”==”运算符，而是根据equals方法。也就是说，我们在加入一个新元素的时候，如果这个新元素对象和Set中已有对象进行注意equals比较都返回false，则Set就会接受这个新元素对象，否则拒绝。

因为Set的这个制约，在使用Set集合的时候，应该注意两点：

1) 为Set集合里的元素的实现类实现一个有效的equals(Object)方法
2) 对Set的构造函数，传入的Collection参数不能包含重复的元素

1.1) HashSet

HashSet是Set接口的典型实现，HashSet使用HASH算法来存储集合中的元素，因此具有良好的存取和查找性能。当向HashSet集合中存入一个元素时，HashSet会调用该对象的hashCode()方法来得到该对象的hashCode值，然后根据该HashCode值决定该对象在HashSet中的存储位置。

值得主要的是，HashSet集合判断两个元素相等的标准是两个对象通过equals()方法比较相等，并且两个对象的hashCode()方法的返回值相等。

1.1.1) LinkedHashSet

LinkedHashSet集合也是根据元素的hashCode值来决定元素的存储位置，但和HashSet不同的是，它同时使用链表维护元素的次序，这样使得元素看起来是以插入的顺序保存的。

当遍历LinkedHashSet集合里的元素时，LinkedHashSet将会按元素的添加顺序来访问集合里的元素。

LinkedHashSet需要维护元素的插入顺序，因此性能略低于HashSet的性能，但在迭代访问Set里的全部元素时(遍历)将有很好的性能(链表很适合进行遍历)。

1.2) SortedSet

此接口主要用于排序操作，即实现此接口的子类都属于排序的子类

1.2.1) TreeSet

TreeSet是SortedSet接口的实现类，TreeSet可以确保集合元素处于排序状态

1.3) EnumSet

EnumSet是一个专门为枚举类设计的集合类，EnumSet中所有元素都必须是指定枚举类型的枚举值，该枚举类型在创建EnumSet时显式、或隐式地指定。EnumSet的集合元素也是有序的，它们以枚举值在Enum类内的定义顺序来决定集合元素的顺序。

2) List

List集合代表一个元素有序、可重复的集合，集合中每个元素都有其对应的顺序索引。List集合允许加入重复元素，因为它可以通过索引来访问指定位置的集合元素。List集合默认按元素的添加顺序设置元素的索引。

2.1) ArrayList

ArrayList是基于数组实现的List类，它封装了一个动态的增长的、允许再分配的Object[]数组。

2.2) Vector

Vector和ArrayList在用法上几乎完全相同，但由于Vector是一个古老的集合，所以Vector提供了一些方法名很长的方法，但随着JDK1.2以后，java提供了系统的集合框架，就将Vector改为实现List接口，统一归入集合框架体系中。

2.2.1) Stack

Stack是Vector提供的一个子类，用于模拟”栈”这种数据结构(LIFO后进先出)。

2.3) LinkedList

implements List, Deque。实现List接口，能对它进行队列操作，即可以根据索引来随机访问集合中的元素。同时它还实现Deque接口，即能将LinkedList当作双端队列使用。自然也可以被当作”栈来使用”。

3) Queue

Queue用于模拟”队列”这种数据结构(先进先出 FIFO)。队列的头部保存着队列中存放时间最长的元素，队列的尾部保存着队列中存放时间最短的元素。新元素插入(offer)到队列的尾部，访问元素(poll)操作会返回队列头部的元素，队列不允许随机访问队列中的元素。结合生活中常见的排队就会很好理解这个概念。

3.1) PriorityQueue

PriorityQueue并不是一个比较标准的队列实现，PriorityQueue保存队列元素的顺序并不是按照加入队列的顺序，而是按照队列元素的大小进行重新排序，这点从它的类名也可以看出来。

3.2) Deque

Deque接口代表一个”双端队列”，双端队列可以同时从两端来添加、删除元素，因此Deque的实现类既可以当成队列使用、也可以当成栈使用。

3.2.1) ArrayDeque

是一个基于数组的双端队列，和ArrayList类似，它们的底层都采用一个动态的、可重分配的Object[]数组来存储集合元素，当集合元素超出该数组的容量时，系统会在底层重新分配一个Object[]数组来存储集合元素。

4) Map

Map用于保存具有”映射关系”的数据，因此Map集合里保存着两组值，一组值用于保存Map里的key，另外一组值用于保存Map里的value。key和value都可以是任何引用类型的数据。Map的key不允许重复，即同一个Map对象的任何两个key通过equals方法比较结果总是返回false。

关于Map，我们要从代码复用的角度去理解，java是先实现了Map，然后通过包装了一个所有value都为null的Map就实现了Set集合。

Map的这些实现类和子接口中key集的存储形式和Set集合完全相同(即key不能重复)

Map的这些实现类和子接口中value集的存储形式和List非常类似(即value可以重复、根据索引来查找)

4.1) HashMap

和HashSet集合不能保证元素的顺序一样，HashMap也不能保证key-value对的顺序。并且类似于HashSet判断两个key是否相等的标准也是: 两个key通过equals()方法比较返回true、同时两个key的hashCode值也必须相等。

4.1.1) LinkedHashMap

LinkedHashMap也使用双向链表来维护key-value对的次序，该链表负责维护Map的迭代顺序，与key-value对的插入顺序一致(注意和TreeMap对所有的key-value进行排序进行区分)

4.2) Hashtable

是一个古老的Map实现类

4.2.1) Properties

Properties对象在处理属性文件时特别方便(windows平台上的.ini文件)，Properties类可以把Map对象和属性文件关联起来，从而可以把Map对象中的key-value对写入到属性文件中，也可以把属性文件中的”属性名-属性值”加载到Map对象中。

4.3) SortedMap

正如Set接口派生出SortedSet子接口，SortedSet接口有一个TreeSet实现类一样，Map接口也派生出一个SortedMap子接口，SortedMap接口也有一个TreeMap实现类。

4.3.1) TreeMap

TreeMap就是一个红黑树数据结构，每个key-value对即作为红黑树的一个节点。TreeMap存储key-value对(节点)时，需要根据key对节点进行排序。TreeMap可以保证所有的key-value对处于有序状态。同样，TreeMap也有两种排序方式: 自然排序、定制排序。

4.4) WeakHashMap

WeakHashMap与HashMap的用法基本相似。区别在于，HashMap的key保留了对实际对象的”强引用”，这意味着只要该HashMap对象不被销毁，该HashMap所引用的对象就不会被垃圾回收。但WeakHashMap的key只保留了对实际对象的弱引用，这意味着如果WeakHashMap对象的key所引用的对象没有被其他强引用变量所引用，则这些key所引用的对象可能被垃圾回收，当垃圾回收了该key所对应的实际对象之后，WeakHashMap也可能自动删除这些key所对应的key-value对。

4.5) IdentityHashMap

IdentityHashMap的实现机制与HashMap基本相似，在IdentityHashMap中，当且仅当两个key严格相等(key1 == key2)时，IdentityHashMap才认为两个key相等。

4.6) EnumMap

EnumMap是一个与枚举类一起使用的Map实现，EnumMap中的所有key都必须是单个枚举类的枚举值。创建EnumMap时必须显式或隐式指定它对应的枚举类。EnumMap根据key的自然顺序(即枚举值在枚举类中的定义顺序)。

【转】Java集合类: Set、List、Map、Queue使用场景梳理_第1张图片

3. Java集合类的应用场景代码

学习了集合类的基本架构框架之后，我们接着来学习它们各自的应用场景、以及细节处的注意事项

0x1: Set

HashSet

package com.zhihua.set;
import java.util.HashSet;
import java.util.Set;

public class HashSetDemo {

    //类A的equals方法总是返回true,但没有重写其hashCode()方法。不能保证当前对象是HashSet中的唯一对象
    class A
    {
        public boolean equals(Object obj)
        {
            return true;
        }
    }
    //类B的hashCode()方法总是返回1,但没有重写其equals()方法。不能保证当前对象是HashSet中的唯一对象
    class B
    {
        public int hashCode()
        {
            return 1;
        }
    }

    //类C的hashCode()方法总是返回2,且有重写其equals()方法
    class C
    {
        public int hashCode()
        {
            return 2;
        }
        public boolean equals(Object obj)
        {
            return true;
        }
    }

    public static void main(String[] args) 
    {
        Set books = new HashSet<>();
        HashSetDemo demo = new HashSetDemo();
        //分别向books集合中添加两个A对象，两个B对象，两个C对象
        books.add(demo.new A());
        books.add(demo.new A());

        books.add(demo.new B());
        books.add(demo.new B());

        books.add(demo.new C());
        books.add(demo.new C());
        System.out.println(books);
        for (Object o : books) {
            System.out.println(o);
        }
    }
}
 
  
result:
 
  
[B@1, B@1, C@2, A@3bc257, A@785d65]
 
  
可以看到，如果两个对象通过equals()方法比较返回true，但这两个对象的hashCode()方法返回不同的hashCode值时，这将导致HashSet会把这两个对象保存在Hash表的不同位置，从而使对象可以添加成功，这就与Set集合的规则有些出入了。所以，我们要明确的是: equals()决定是否可以加入HashSet、而hashCode()决定存放的位置，它们两者必须同时满足才能允许一个新元素加入HashSet。
 
  
但是要注意的是: 如果两个对象的hashCode相同，但是它们的equlas返回值不同，HashSet会在这个位置用链式结构来保存多个对象。而HashSet访问集合元素时也是根据元素的HashCode值来快速定位的，这种链式结构会导致性能下降。
 
  
所以如果需要把某个类的对象保存到HashSet集合中，我们在重写这个类的equlas()方法和hashCode()方法时，应该尽量保证两个对象通过equals()方法比较返回true时，它们的hashCode()方法返回值也相等。
 
  
LinkedHashSet
 
  
package com.zhihua.set;

import java.util.LinkedHashSet;
import java.util.Set;

public class LinkedHashSetDemo {

    public static void main(String[] args) {
        Set books = new LinkedHashSet<>();
        books.add("Java");
        books.add("LittleHann");
        System.out.println(books);

        // 删除 Java
        books.remove("Java");
        // 重新添加 Java
        books.add("Java");
        System.out.println(books);
    }
}

 
  
元素的顺序总是与添加顺序一致，同时要明白的是，LinkedHashSet是HashSet的子类，因此它不允许集合元素重复
 
  
TreeSet
 
  
package com.zhihua.set;

import java.util.TreeSet;

public class TreeSetDemo {

    public static void main(String[] args) {

        TreeSet nums = new TreeSet<>();
        // 向TreeSet中添加四个Integer对象
        nums.add(5);
        nums.add(2);
        nums.add(10);
        nums.add(-9);

        // 输出集合元素，看到集合元素已经处于排序状态
        System.out.println(nums);

        // 输出集合里的第一个元素
        System.out.println(nums.first());

        // 删除集合中的最后一个元素
        System.out.println(nums.last());

        // 返回小于4的子集，不包含4
        System.out.println(nums.headSet(4));

        // 返回大于5的子集，如果set包含5，子集中还包含5
        System.out.println(nums.tailSet(5));

        // 返回大于等于-3，小于4的子集
        System.out.println(nums.subSet(-3, 4));
    }
}
 
  
与HashSet集合采用hash算法来决定元素的存储位置不同，TreeSet采用红黑树的数据结构来存储集合元素。
 
  
TreeSet支持两种排序方式: 自然排序、定制排序
 
  
1. 自然排序:
 
  
TreeSet会调用集合元素的compareTo(Object obj)方法来比较元素之间的大小关系，然后将集合元素按升序排序，即自然排序。如果试图把一个对象添加到TreeSet时，则该对象的类必须实现Comparable接口，否则程序会抛出异常。
 
  
当把一个对象加入TreeSet集合中时，TreeSet会调用该对象的compareTo(Object obj)方法与容器中的其他对象比较大小，然后根据红黑树结构找到它的存储位置。如果两个对象通过compareTo(Object obj)方法比较相等，新对象将无法添加到TreeSet集合中(牢记Set是不允许重复的概念)。
 
  
注意: 当需要把一个对象放入TreeSet中，重写该对象对应类的equals()方法时，应该保证该方法与compareTo(Object obj)方法有一致的结果，即如果两个对象通过equals()方法比较返回true时，这两个对象通过compareTo(Object obj)方法比较结果应该也为0(即相等)。
 
  
看到这里，我们应该明白：
 
  
1) 对与Set来说，它定义了equals()为唯一性判断的标准，而对于到了具体的实现，
HashSet、TreeSet来说，它们又会有自己特有的唯一性判断标准，
只有同时满足了才能判定为唯一性
2) 我们在操作这些集合类的时候，对和唯一性判断有关的函数重写要重点关注
 
  
2. 定制排序
 
  
TreeSet的自然排序是根据集合元素的大小，TreeSet将它们以升序排序。如果我们需要实现定制排序，则可以通过Comparator接口的帮助(类似PHP中的array_map回调处理函数的思想)。该接口里包含一个int compare(T o1， T o2)方法，该方法用于比较大小。
 
  
package com.zhihua.set;

import java.util.Comparator;
import java.util.TreeSet;

import com.sun.org.apache.bcel.internal.generic.NEW;

/**
 * Comparator
 * @author caizh
 *
 */
public class TreeSetDemo2 {

    public static void main(String[] args) {

        TreeSet treeSet = new TreeSet(new Comparator() {

            @Override
            public int compare(Object o1, Object o2) {
                M m1 = (M) o1;
                M m2 = (M) o2;
                // 从大到小排序
                return m1.age>m2.age?-1:(m1.age1:0);
            }
        });

        treeSet.add(new M(5));
        treeSet.add(new M(-3));
        treeSet.add(new M(9));
        System.out.println(treeSet);
    }
}

class M {
    int age;
    public M(int age) {
        this.age = age;
    }
    public String toString(){
        return "M[age:"+ age + "]";
    }
} 
  
看到这里，我们需要梳理一下关于排序的概念
 
  
1) equals、compareTo决定的是怎么比的问题，即用什么field进行大小比较
2) 自然排序、定制排序、Comparator决定的是谁大的问题，即按什么顺序(升序、降序)进行排序
它们的关注点是不同的，一定要注意区分
 
  
EnumSet
 
  
package com.zhihua.set;

import java.util.EnumSet;

public class EnumSetDemo {

    public static void main(String[] args) {

        // 创建一个EnumSet集合，集合元素就是Season枚举类的全部枚举值
        EnumSet enumSet = EnumSet.allOf(Season.class);

        //输出[SPRING,SUMMER,FALL,WINTER]
        System.out.println(enumSet);

        // 创建一个EnumSet空集合，指定其集合元素是Season类的枚举值
        EnumSet enumSet2 = EnumSet.noneOf(Season.class);
        // 输出
        System.out.println(enumSet2);
        // 手动添加两个元素
        enumSet2.add(Season.WINTER);
        enumSet2.add(Season.SPRING);
        //输出[SPRING,WINTER]
        System.out.println(enumSet2);

        // 以指定枚举值创建EnumSet集合
        EnumSet enumSet3 = EnumSet.of(Season.SUMMER,Season.WINTER);
        //输出[SUMMER,WINTER]
        System.out.println(enumSet3);

        EnumSet enumSet4 = EnumSet.range(Season.SUMMER , Season.WINTER); 
        //输出[SUMMER,FALL,WINTER]-FALL在SUMMER,WINTER之间
        System.out.println(enumSet4);

        //新创建的EnumSet集合的元素和es4集合的元素有相同类型，
        //es5的集合元素 + es4集合元素 = Season枚举类的全部枚举值
        EnumSet enumSet5 = EnumSet.complementOf(enumSet4); 
        //输出[SPRING]
        System.out.println(enumSet5);


    }
}

enum Season{
    SPRING,SUMMER,FALL,WINTER
}
 
  
以上就是Set集合类的编程应用场景。那么应该怎样选择何时使用这些集合类呢？
 
  
1) HashSet的性能总是比TreeSet好(特别是最常用的添加、查询元素等操作)，
因为TreeSet需要额外的红黑树算法来维护集合元素的次序。
只有当需要一个保持排序的Set时，才应该使用TreeSet，否则都应该使用HashSet
2) 对于普通的插入、删除操作，LinkedHashSet比HashSet要略慢一点，
这是由维护链表所带来的开销造成的。
不过，因为有了链表的存在，遍历LinkedHashSet会更快
3) EnumSet是所有Set实现类中性能最好的，但它只能保存同一个枚举类的枚举值作为集合元素
4) HashSet、TreeSet、EnumSet都是"线程不安全"的，
通常可以通过Collections工具类的synchronizedSortedSet方法来"包装"该Set集合。
SortedSet s = Collections.synchronizedSortedSet(new TreeSet(...));
 
  
0x2: List
 
  
ArrayList
 
  
如果一开始就知道ArrayList集合需要保存多少元素，则可以在创建它们时就指定initialCapacity大小，这样可以减少重新分配的次数，提供性能，ArrayList还提供了如下方法来重新分配Object[]数组。
 
  
1) ensureCapacity(int minCapacity): 将ArrayList集合的Object[]数组长度增加minCapacity
2) trimToSize(): 调整ArrayList集合的Object[]数组长度为当前元素的个数。
程序可以通过此方法来减少ArrayList集合对象占用的内存空间
 
  
package com.zhihua.list;

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

public class ArrayListDemo {

    public static void main(String[] args) {

        List books = new ArrayList<>();
        // 向books集合中添加三个元素
        books.add(new String("轻量级Java EE企业应用实战"));
        books.add(new String("疯狂Java讲义"));
        books.add(new String("疯狂Android讲义"));
        System.out.println(books);

        // 将新字符串对象插入在第二个位置
        books.add(1, new String("疯狂Ajax讲义"));
        for (String str : books) {
            System.out.println(str);
        }

        // 删除第三个元素
        books.remove(2);
        System.out.println(books);

        // 判断指定元素在List集合中位置：输出1，表明位于第二位
        System.out.println(books.indexOf(new String("疯狂Ajax讲义")));

        // 将第二个元素替换成新的字符串对象
        books.set(1, new String("LittleHann"));
        System.out.println(books);

        // 将books集合的第二个元素（包括）
        // 到第三个元素（不包括）截取成子集合
        System.out.println(books.subList(1, 2));
    }
}

 
  
Stack
 
  
注意Stack的后进先出的特点
 
  
package com.zhihua.list;

import java.util.Stack;

public class StackDemo {

    public static void main(String[] args) {

        Stack v = new Stack<>();
        // 依次将三个元素push入 “栈”
        v.push("疯狂Java讲义");
        v.push("轻量级Java EE企业应用实战");
        v.push("疯狂Android讲义");

        //输出：[疯狂Java讲义, 轻量级Java EE企业应用实战 , 疯狂Android讲义]
        System.out.println(v);

        // 访问第一个元素，但并不将其pop出“栈”，输出：疯狂Android讲义
        System.out.println(v.peek());

        // 依然输出：[疯狂Java讲义, 轻量级Java EE企业应用实战 , 疯狂Android讲义]
        System.out.println(v);

        // pop出第一个元素，输出：疯狂Android讲义
        System.out.println(v.pop());

         //输出：[疯狂Java讲义, 轻量级Java EE企业应用实战]
        System.out.println(v);

    }
}

 
  
LinkedList
 
  
package com.zhihua.list;

import java.util.LinkedList;

public class LinkedListDemo {

    public static void main(String[] args) {

        LinkedList books = new LinkedList<>();
        // 将字符串元素加入队列的尾部（双端队列）
        books.offer("疯狂Java讲义");
        // 将一个字符串元素加入栈的顶部（双端队列）
        books.push("轻量级Java EE企业应用实战");

        // 将字符串元素添加到队列的头（相当于栈的顶部）
        books.offerFirst("疯狂Android讲义");

        for(int i=0;iout.println(books.get(i));
        }

        // 访问，并不删除栈顶的元素
        System.out.println(books.peekFirst());

        // 访问，并不删除队列的最后一个元素
        System.out.println(books.peekLast());

        // 将栈顶的元素弹出“栈”
        System.out.println(books.pop());

        // 下面输出将看到队列中第一个元素被删除
        System.out.println(books);

        // 访问，并删除队列的最后一个元素
        System.out.println(books.pollLast());
        // 下面输出将看到队列中只剩下中间一个元素
        // 轻量级Java EE企业应用实战
        System.out.println(books);
    }
}

 
  
从代码中我们可以看到，LinkedList同时表现出了双端队列、栈的用法。功能非常强大
 
  
0x3: Queue
 
  
PriorityQueue
 
  
package com.zhihua.queue;

import java.util.PriorityQueue;

public class PriorityQueueDemo {

    public static void main(String[] args) {

        PriorityQueue queue = new PriorityQueue<>();
        // 下面代码依次向queue中加入四个元素
        queue.offer(6);
        queue.offer(-3);
        queue.offer(9);
        queue.offer(0);

        // 输出queue队列，并不是按元素的加入顺序排序
        // 而是按照元素的大小顺序排序，输出[-3, 0, 9, 6]
        System.out.println(queue);
        // 访问队列第一个元素，其实就是队列中最小的元素：-3
        System.out.println(queue.poll());
        System.out.println(queue);


    }
}
 
  
PriorityQueue不允许插入null元素，它还需要对队列元素进行排序，PriorityQueue的元素有两种排序方式
 
  
1) 自然排序:
采用自然顺序的PriorityQueue集合中的元素对象都必须实现了Comparable接口，
而且应该是同一个类的多个实例，否则可能导致ClassCastException异常
2) 定制排序
创建PriorityQueue队列时，传入一个Comparator对象，该对象负责对队列中的所有元素
进行排序
关于自然排序、定制排序的原理和之前说的TreeSet类似
 
  
ArrayDeque
 
  
package com.zhihua.queue;

import java.util.ArrayDeque;

public class ArrayDequeDemo {

    public static void main(String[] args) {

        ArrayDeque stack = new ArrayDeque<>();
        // 依次将三个元素push入"栈"
        stack.push("疯狂Java讲义");
        stack.push("轻量级Java EE企业应用实战");
        stack.push("疯狂Android讲义");

        // 输出：[疯狂Java讲义, 轻量级Java EE企业应用实战 , 疯狂Android讲义]
        System.out.println(stack);

        // 访问第一个元素，但并不将其pop出"栈",输出：疯狂Android讲义
        System.out.println(stack.peek());

        // 依然输出：[疯狂Java讲义, 轻量级Java EE企业应用实战 , 疯狂Android讲义]
        System.out.println(stack);

        // pop出第一个元素，输出：疯狂Android讲义
        System.out.println(stack.pop());

        // 输出：[疯狂Java讲义, 轻量级Java EE企业应用实战]
        System.out.println(stack);
    }
}

 
  
以上就是List集合类的编程应用场景。我们来梳理一下思路
 
  
1. java提供的List就是一个"线性表接口"，ArrayList(基于数组的线性表)、
LinkedList(基于链的线性表)是线性表的两种典型实现
2. Queue代表了队列，Deque代表了双端队列(既可以作为队列使用、也可以作为栈使用)
3. 因为数组以一块连续内存来保存所有的数组元素，所以数组在随机访问时性能最好。
所以的内部以数组作为底层实现的集合在随机访问时性能最好。
4. 内部以链表作为底层实现的集合在执行插入、删除操作时有很好的性能
5. 进行迭代操作时，以链表作为底层实现的集合比以数组作为底层实现的集合性能好
 
  
我们之前说过，Collection接口继承了Iterable接口，也就是说，我们以上学习到的所有的Collection集合类都具有”可遍历性”。
 
  
Iterable接口也是java集合框架的成员，它隐藏了各种Collection实现类的底层细节，向应用程序提供了遍历Collection集合元素的统一编程接口:
 
  
1) boolean hasNext(): 是否还有下一个未遍历过的元素
2) Object next(): 返回集合里的下一个元素
3) void remove(): 删除集合里上一次next方法返回的元素
 
  
iterator实现遍历:
 
  
package com.zhihua.set;

import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;

public class IteratorDemo {

    public static void main(String[] args) {

        // 创建一个集合
        Collection books = new HashSet<>();
        books.add("轻量级Java EE企业应用实战");
        books.add("疯狂Java讲义");
        books.add("疯狂Android讲义");

        // 获取books集合对应的迭代器
        Iterator it = books.iterator();
        while(it.hasNext()) {
            // it.next()方法返回的数据类型是Object类型
            // 需要强制类型转换,加了泛型后，就可以确定类型
            String book = it.next();
            System.out.println(book);
            if("疯狂Java讲义".equals(book)) {
                // 从集合中删除上一次next方法返回的元素
                it.remove();
            }
            // 对book变量赋值，不会改变集合元素本身
            book = "测试字符串";
        }
        System.out.println(books);
    }
}

 
  
从代码可以看出，iterator必须依附于Collection对象，若有一个iterator对象，必然有一个与之关联的Collection对象。
 
  
除了可以使用iterator接口迭代访问Collection集合里的元素之外，使用java5提供的foreach循环迭代访问集合元素更加便捷：
 
  
foreach实现遍历:
 
  
package com.zhihua.set;

import java.util.Collection;
import java.util.HashSet;

public class ForeachDemo {

    public static void main(String[] args) {

        // 创建一个集合
        Collection books = new HashSet<>();
        books.add(new String("轻量级Java EE企业应用实战"));
        books.add(new String("疯狂Java讲义"));
        books.add(new String("疯狂Android讲义"));

        for (String book : books) {
            System.out.println(book);
            if (book.equals("疯狂Android讲义"))
            {
                //下面代码会引发ConcurrentModificationException异常
                //books.remove(book);      
            }
        }
        System.out.println(books);
    }
}

 
  
除了Collection固有的iterator()方法，List还额外提供了一个listIterator()方法，该方法返回一个ListIterator对象，ListIterator接口继承了Iterator接口，提供了专门操作List的方法。ListIterator接口在Iterator接口的继承上增加了如下方法:
 
  
1) boolean hasPrevious(): 返回该迭代器关联的集合是否还有上一个元素
2) Object previous(): 返回该迭代器的上一个元素(向前迭代)
3) void add(): 在指定位置插入一个元素
 
  
ListIterator实现遍历:
 
  
package com.zhihua.set;

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

public class ListIteratorDemo {

    public static void main(String[] args) {

        String[] books = {
                "疯狂Java讲义",
                "轻量级Java EE企业应用实战"
        };
        List bookList = new ArrayList<>();
        for(int i=0;i
            bookList.add(books[i]);
        }
        ListIterator lit = bookList.listIterator();
        while(lit.hasNext()) {
            System.out.println(lit.next());
            lit.add("-------分隔符-------");
        }
        System.out.println("=======下面开始反向迭代==========");
        while(lit.hasPrevious()) {
            System.out.println(lit.previous());
        }
    }
}

 
  
0x4: Map
 
  
HashMap、Hashtable
 
  
package com.zhihua.map;

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

public class HashtableDemo {

    public static void main(String[] args) {
        Map map = new HashMap<>();
        Map ht = new Hashtable<>();
        ht.put(new A(60000) , "疯狂Java讲义");
        ht.put(new A(87563) , "轻量级Java EE企业应用实战");
        ht.put(new A(1232) , new B());
        System.out.println(ht);

        // 只要两个对象通过equals比较返回true
        // Hashtable就认为它们是相等的value
        // 由于Hashtable中有一个B对象
        // 它与任何对象通过equals比较都相等，所以下面输出true
        System.out.println(ht.containsValue("测试字符串"));

        // 只要两个A对象的count相等，它们通过equals比较返回true，且hashCode相等
        // Hashtable即认为它们是相等的key，所有下面输出true
        System.out.println(ht.containsKey(new A(87563)));

        // 下面语句可以删除最后一个key-value对
        ht.remove(new A(1232)); 

        // 通过返回Hashtable的所有key组成的set集合
        // 从而遍历Hashtable每个key-value对
        for(Object key:ht.keySet()) {
            System.out.print(key + "---->");
            System.out.print(ht.get(key) + "\n");
        }
    }
}
class A{
    int count;
    public A(int count) {
        this.count = count;
    }
    // 根据count的值来判断两个对象是否相等
    public boolean equals(Object obj) {
        if(obj==this) {
            return true;
        }
        if(obj!=null && obj.getClass()==A.class) {
            A a = (A) obj;
            return this.count == a.count;
        }
        return false;
    }
     //根据count来计算hashCode值。
    public int hashCode()
    {
        return this.count;
    }
}
class B
{
    //重写equals()方法，B对象与任何对象通过equals()方法比较都相等
    public boolean equals(Object obj)
    {
        return true;
    }
}
 
  
当使用自定义类作为HashMap、Hashtable的key时，如果重写该类的equals(Object obj)和hashCode()方法，则应该保证两个方法的判断标准一致–当两个key通过equals()方法比较返回true时，两个key的hashCode()的返回值也应该相同。
 
  
LinkedHashMap
 
  
package com.zhihua.map;

import java.util.LinkedHashMap;

public class LinkedHashMapDemo {

    public static void main(String[] args) {

        LinkedHashMap scores = new LinkedHashMap<>();
        scores.put("语文",80);
        scores.put("英文",82);
        scores.put("数学",76);

        // 遍历scores里的所有的key-value对
        for(Object key: scores.keySet()) {
            System.out.println(key + "------>" + scores.get(key));
        }
    }
}

 
  
Properties
 
  
package com.zhihua.map;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.Properties;

public class PropertiesDemo {

    public static void main(String[] args) throws Exception{

        Properties props = new Properties();
        // 向Properties中增加属性
        props.setProperty("username", "yeeku");
        props.setProperty("password", "123456");

        // 将Properties中的key-value对保存到a.ini文件中
        props.store(new FileOutputStream("E:/a.ini"), "comment line");

        // 新建一个Properties对象
        Properties props2 = new Properties();
        // 向Properties中增加属性
        props2.setProperty("gender", "male");

        // 将a.ini文件中的key-value对追加到props2中
        props2.load(new FileInputStream("E:/a.ini"));
        System.out.println(props2);
    }
}

 
  
Properties还可以把key-value对以XML文件的形式保存起来，也可以从XML文件中加载key-value对。
 
  
TreeMap
 
  
package com.zhihua.map;

import java.util.TreeMap;

public class TreeMapDemo {

    public static void main(String[] args) {

        TreeMap tm = new TreeMap<>();
        tm.put(new R(3), "轻量级Java EE企业应用实战");
        tm.put(new R(-5) , "疯狂Java讲义");
        tm.put(new R(9) , "疯狂Android讲义");

        System.out.println(tm);

        // 返回该TreeMap的第一个Entry对象
        System.out.println(tm.firstEntry());

        // 返回该TreeMap的最后一个key值
        System.out.println(tm.lastKey());

        // 返回该TreeMap的比 new R(2)大的最小key的值
        System.out.println(tm.higherKey(new R(2)));

        //返回该TreeMap的比new R(2)小的最大的key-value对。
        System.out.println(tm.lowerEntry(new R(2)));

        //返回该TreeMap的子TreeMap
        System.out.println(tm.subMap(new R(-1) , new R(4)));

    }
}
class R implements Comparable{

    int count;
    public R(int count) {
        this.count = count;
    }
    public String toString() {
        return "R[count:" + count + "]";
    }

    // 根据count来判断两个对象是否相等
    public boolean equals(Object obj) {

        if(this==obj) {
            return true;
        }
        if(obj!=null && obj.getClass()==R.class) {
            R r = (R) obj;
            return r.count == this.count;
        }
        return false;
    }

    // 根据count属性值来判断两个对象的大小
    @Override
    public int compareTo(Object o) {
        R r = (R)o;
        return count > r.count ? 1 :
            count < r.count ? -1 : 0;
    }

}

 
  
从代码中可以看出，类似于TreeSet中判断两个元素是否相等的标准，TreeMap中判断两个key相等的标准是: 
 
  
1) 两个key通过compareTo()方法返回0
2) equals()返回true
 
  
我们在重写这两个方法的时候一定要保证它们的逻辑关系一致。
 
  
再次强调一下:
 
  
Set和Map的关系十分密切，java源码就是先实现了HashMap、TreeMap等集合，
然后通过包装一个所有的value都为null的Map集合实现了Set集合类
 
  
WeakHashMap
 
  
package com.zhihua.map;

import java.util.WeakHashMap;

public class WeakHashMapDemo {

    public static void main(String[] args) {

        WeakHashMap whm = new WeakHashMap<>();
        //将WeakHashMap中添加三个key-value对，
        // 三个key都是匿名字符串对象（没有其他引用）
        whm.put(new String("语文"), new String("良好"));
        whm.put(new String("数学"), new String("及格"));
        whm.put(new String("英文"), new String("中等"));

        // 将WeakHashMap中添加一个key-value对，
        // 该key是一个系统缓存的字符串对象，"java"是一个常量字符串强引用
        whm.put("java", new String("中等"));
        // 输出whm对象，将看到4个key-value对
        System.out.println(whm);
        // 通知系统立即进行垃圾回收
        System.gc();
        System.runFinalization();
        // 通常情况下，将只看到一个key-value对
        System.out.println(whm);
    }
}

 
  
如果需要使用WeakHashMap的key来保留对象的弱引用，则不要让key所引用的对象具有任何强引用，否则将失去使用WeakHashMap的意义。
 
  
IdentityHashMap
 
  
package com.zhihua.map;

import java.util.IdentityHashMap;

public class IdentityHashMapDemo {

    public static void main(String[] args) {

        IdentityHashMap ihm = new IdentityHashMap<>();
        // 下面两行代码将会向IdentityHashMap对象中添加两个key-value对
        ihm.put(new String("语文"),89);
        ihm.put(new String("语文"),78);

        // 下面两行代码只会向IdentityHashMap对象中添加一个key-value对
        ihm.put("java", 93);
        ihm.put("java", 98);
        System.out.println(ihm);
    }
}

 
  
EnumMap
 
  
package com.zhihua.map;

import java.util.EnumMap;

public class EnumMapDemo {

    public static void main(String[] args) {

        // 创建一个EnumMap对象，该EnumMap的所有的key
        // 必须是Season枚举类的枚举值
        EnumMap enumMap = new EnumMap<>(Season.class);
        enumMap.put(Season.SUMMER, "夏日炎炎");
        enumMap.put(Season.SPRING, "春暖花开");

        System.out.println(enumMap);
    }
}

enum Season{
    SPRING,SUMMER,FALL,WINTER;
}
 
  
与创建普通Map有所区别的是，创建EnumMap是必须指定一个枚举类，从而将该EnumMap和指定枚举类关联起来。
 
  
以上就是Map集合类的编程应用场景。我们来梳理一下思路
 
  
1) HashMap和Hashtable的效率大致相同，因为它们的实现机制几乎完全一样。
但HashMap通常比Hashtable要快一点，因为Hashtable需要额外的线程同步控制
2) TreeMap通常比HashMap、Hashtable要慢(尤其是在插入、删除key-value对时更慢)，
因为TreeMap底层采用红黑树来管理key-value对
3) 使用TreeMap的一个好处就是： TreeMap中的key-value对总是处于有序状态，无须专门进行排序操作。
 
  
 
  
 
  
 
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Java基础)

        

            

                
    
                    
  • JAVA·一个简单的登录窗口
                        MortalTom
java开发语言学习
                        
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
    
                    
    • 
                    
  • 互联网 Java 工程师面试题（Java 面试题四）
                        苹果酱0567
面试题汇总与解析java中间件开发语言springboot后端
                        
    下面列出这份Java面试问题列表包含的主题多线程，并发及线程基础数据类型转换的基本原则垃圾回收（GC）Java集合框架数组字符串GOF设计模式SOLID抽象类与接口Java基础，如equals和hashcode泛型与枚举JavaIO与NIO常用网络协议Java中的数据结构和算法正则表达式JVM底层Java最佳实JDBCDate,Time与CalendarJava处理XMLJUnit编程现在是时候给
    
                    
    • 
                    
  • JAVA相关知识
                        M_灵均
javajvm开发语言
                        
    JAVA基础知识说一下对象创建的过程？类加载检查：当Java虚拟机（JVM）遇到一个类的new指令时，它首先检查这个类是否已经被加载、链接和初始化。如果没有，JVM会通过类加载器（ClassLoader）加载这个类。分配内存：JVM为新对象分配内存。这个内存分配是在堆（Heap）上进行的，堆是JVM用来存储对象实例的地方。分配内存的大小在类加载时就已经确定，因为类的结构（包括字段和方法）已经确定。
    
                    
    • 
                    
  • 字节跳动面试官亲述：Android开发学会了这些技术，你离大厂不远了
                        m0_65322636
程序员架构移动开发android
                        
    HTTPSHTTP是超文本传输协议，明文传输；HTTPS使用SSL协议对HTTP传输数据进行了加密HTTP默认80端口；HTTPS默认443端口优点：安全缺点：费时、SSL证书收费，加密能力还是有限的，但是比HTTP强多了2、Java基础&容器&同步&设计模式StringBuilder、StringBuffer、+、String.concat链接字符串：StringBuffer线程安全，Strin
    
                    
    • 
                    
  • Java基础一
                        十一路客
java开发语言
                        
    哔哩哔哩Java开发工程师面试该如（）何准备？-知乎一.JavaOOP面试题(1)什么是B/S架构?什么是C/S架构Java都有那些开发平台?B/S(Browser/Server)，浏览器/服务器程序C/S(Client/Server)，客户端/服务端，桌面应用程序1、C/S和B/S各有优势，C/S在图形的表现能力上以及运行的速度上肯定是强于B/S模式的，不过缺点就是他需要运行专门的客户端，而且更
    
                    
    • 
                    
  • Java 学习路线：语言、框架、中间件与数据库
                        高危型
java
                        
    Java是一门功能强大、应用广泛的编程语言，适用于企业级应用、Web开发、大数据处理、Android开发等各种场景。这里为大家介绍了一下我认为较为合适的学习路线一、Java基础1.1Java语言基础1.1.1安装JDK和IDE安装JDK：下载JDK：访问Oracle官网，下载最新的JavaDevelopmentKit（JDK）。安装JDK：按照操作系统要求安装JDK并配置环境变量。Windows上
    
                    
    • 
                    
  • java基础-线程间通信方式
                        问道飞鱼
Java开发技术java开发语言
                        
    文章目录1.wait()和notify()2.volatile关键字3.Java.util.concurrent包提供的工具类Semaphore（信号量）BlockingQueue（阻塞队列）4.Atomic类在Java中，线程间的通信是非常重要的，尤其是在多线程编程中，它有助于协调线程的行为，确保资源的正确访问和更新。Java提供了多种方式来实现线程间的通信，主要包括以下几种方法：1.wait(
    
                    
    • 
                    
  • Java并发复习
                        vd_vd
Java并发安全容器java开发语言
                        
    Java基础1.为什么要使用并发编程？一般我们工作的电脑都有多核，我们创建多个线程，然后操作系统可以将多个线程分配给不同的CPU去执行，每个CPU执行一个线程，这样就提高了CPU使用效率。在网络购物中，我们买了一个东西的同时，需要减库存，生成订单等等这些操作，就可以进行拆分利用多线程的技术完成。面对复杂业务模型，并行程序串行会比程序更适应业务需求，而并发编程更能吻合这种业务拆分。->充分利用多核C
    
                    
    • 
                    
  • Android 高频面试必问之Java基础
                        2401_86022611
android面试java
                        
    常用的JVM调参如下表：|参数|作用描述||—|—||-XX:MetaspaceSize|分配给Metaspace（以字节计）的初始大小。如果不设置的话，默认是20.79M，这个初始大小是触发首次MetaspaceFullGC的阈值，例如-XX:MetaspaceSize=256M||-XX:MaxMetaspaceSize|分配给Metaspace的最大值，超过此值就会触发FullGC，此值默认
    
                    
    • 
                    
  • Java基础day08ArrayList和继承
                        没有信仰的小白

                        
    ArrayList类对象数组数组长度是固定，无动态扩容java.util.ArrayList集合类，更方便image无参构造函数image基本格式,Jdk7之后右侧尖括号可以留空，但是必须保留ArrayListlist=newArrayList<>();成员方法添加元素publicbooleanadd(Ee)获取元素publicEget(intindex)集合中的元素publicintsize()
    
                    
    • 
                    
  • java基础系列02--面向对象
                        addin_gao

                        
    java面向对象封装(encapsulation)继承(inheritance)多态(polymorphism)成员变量和局部变量的区别：在类中的位置不同:成员变量：在类中方法外局部变量：在方法定义中或者方法声明上在内存中的位置不同:成员变量：在堆内存(成员变量属于对象,对象进堆内存)局部变量：在栈内存(局部变量属于方法,方法进栈内存)生命周期不同:成员变量：随着对象的创建而存在，随着对象的消失而
    
                    
    • 
                    
  • Java基础全程学习笔记（二）
                        网路侠客
java学习笔记开发语言
                        
    第06章：面向对象-基础#面向对象内容的三条主线：>类及类的内部成员：属性、方法、构造器;代码块、内部类>面向对象的三大特征：封装性、继承性、多态性>其它关键字的使用：package、import、this、super、static、final、abstract、interface等1.理解：面向过程vs面向对象#简单的语言描述二者的区别>面向过程：以`函数`为组织单位。是一种“`执行者思维`”，
    
                    
    • 
                    
  • Java基础：什么是多态
                        试着奔跑的菜鸟
javajava开发语言
                        
    什么是多态多态是面向对象的三大特性之一（另外两个是封装和继承），指的是同一个方法能执行不同的行为，在代码上的体现是：声明为父类的对象，可以被不同的实现类赋值，其中实现类必须继承或者实现父类接口，然后程序在运行时会执行实现类的方法。//如ArrayList和LinkedList都实现了List接口classArrayListimplementsList{}classLinkedListimpleme
    
                    
    • 
                    
  • java基础之继承
                        Absinthe_苦艾酒
java开发语言
                        
    1.一个子类只能有一个直接父类（一个父类可以多个子类）2.private修饰符和void不能继承、不同包不能继承代码如下：父类packagebegan;//定义一个父类publicclassPet01{//属性publicStringname;//方法publicvoidrun(Stringname){System.out.println(name+"running");}}子类packagebe
    
                    
    • 
                    
  • Java基础 --- 多线程&JUC，以及一些常用的设计模式总结
                        lzhlizihang
java设计模式
                        
    文章目录一、多线程1、线程和进程的区别2、创建多线程的四种方式3、集合中的线程安全二、设计模式1、单例模式2、装饰者模式（IO流缓冲流）3、适配器模式4、模板模式一、多线程1、线程和进程的区别进程是操作系统资源分配的基本单位，而线程是处理器任务调度和执行的基本单位，一个进程可以运行多个线程多进程：操作系统中同时运行的多个程序多线程：在同一个进程中同时运行的多个任务2、创建多线程的四种方式Runna
    
                    
    • 
                    
  • Java学习路线：从零基础到高级开发者的完整指南
                        何遇mirror
java
                        
    初学者入门指南1.环境搭建安装JDK:下载并安装最新版本的JDK（JavaDevelopmentKit）。配置环境:设置JAVA_HOME环境变量，并将bin目录添加到PATH中。选择IDE:使用Eclipse、IntelliJIDEA或其他任何你喜欢的Java集成开发环境。2.Java基础知识HelloWorld:编写你的第一个Java程序。基本语法:学习变量、数据类型（原始类型、包装类型）、运
    
                    
    • 
                    
  • Java 学习路线：适合小白的超细学习路线及实例代码
                        Dreams°123
后端javaeclipsejvmspringtomcatideintellij-idea
                        
    Java学习路线：适合小白的超细学习路线及实例代码一、入门基础1.1、Java基础语法1.2、面向对象编程(OOP)二、核心Java编程2.1、数据结构和算法基础2.2、输入输出(I/O)三、进阶Java编程3.1、多线程编程3.2、网络编程四、高级应用4.1、数据库编程4.2、Web开发4.3、框架与库五、实践项目与进阶学习（留作业啦）5.1、实践项目5.2、持续学习一、入门基础1.1、Java
    
                    
    • 
                    
  • Java基础：单例模式，Spring源码中有哪些单例模式
                        生活诙谐号
Java基础Spring源码设计模式单例模式javaspring
                        
    单例模式是一种常用的软件设计模式，其目的是确保一个类仅有一个实例，并提供一个全局访问点来获取这个唯一实例。在Java中，实现单例模式通常需要遵循以下几个关键原则：私有化构造器：将类的构造器声明为private，以防止外部代码通过new操作符直接创建该类的实例。静态工厂方法：提供一个静态方法（通常称为getInstance()），用于获取单例对象。这个方法负责检查是否已经创建过实例，如果尚未创建，则
    
                    
    • 
                    
  • 多线程 03：知识补充，静态代理与 Lambda 表达式的相关介绍，及其在多线程方面的应用
                        蟾宫曲
Java多线程java开发语言多线程静态代理Lambdaintellij-idea
                        
    一、概述记录时间[2024-08-16]前置知识：Java基础篇；Java面向对象多线程01：Java多线程学习导航，线程简介，线程相关概念的整理多线程02：线程实现，创建线程的三种方式，通过多线程下载图片案例分析异同（Thread，Runnable，Callable）Java多线程学习主要模块包括：线程简介；线程实现；线程控制；线程状态；线程同步；线程通信问题；拓展高级主题。本文是针对多线程的相
    
                    
    • 
                    
  • Java基础之Java中的8种基本数据类型
                        w乐生
乐生的Java之路java
                        
    一，8种基本数据类型1，byte：8位1字节，取值范围：2-7----27-12，shot：16位2字节，取值范围：2-15----215-13，int：32位4字节，取值范围：2-31----231-14，long：64位8字节，取值范围：2-63----263-15，float：32位4字节，取值范围：-2-31----231-16，double：64位8字节，取值范围：-2-63----26
    
                    
    • 
                    
  • Java学习路线
                        纣王家子迎新
javajava学习
                        
    一、Java基础阶段‌Java语言基础‌：数据类型与变量：了解Java中的基本数据类型（如int、float、double等）和引用数据类型，掌握变量的声明、初始化和使用。运算符与表达式：学习Java中的算术运算符、关系运算符、逻辑运算符等，以及它们的使用规则和优先级。流程控制：掌握条件语句（if-else）、循环语句（for、while、do-while）和跳转语句（break、continue
    
                    
    • 
                    
  • 2024上学期--实验室学习计划
                        m0_66357705
javascript前端vue.js
                        
    阶段周次学习内容实践内容时间安排新增内容/重点基础巩固1-2周Java基础，多线程，TCP/IP网络编程相关练习和小的编程项目每天学习2小时，实践1小时Java20及以上版本新特性学习框架深入学习3-6周Spring，SpringBoot相关练习和小的编程项目每天学习3小时，实践1.5小时学习SpringCloud和微服务架构基础前端技术提升7-8周Vue2，Vue3相关练习和小的编程项目每天学习
    
                    
    • 
                    
  • Java基础——深入理解Java中的多线程（超级详细，值得你看）
                        2401_84558508
作者\/java开发语言
                        
    开发中优先选择实现Runnable方式原因：实现的方式没有类的单继承性的局限性实现的方式更适合来处理多个线程共享数据的情况相同点：都需要重写run()，将线程要执行的代码声明在run()方法中线程的生命周期解决线程安全问题；使用同步代码块packagecom.haust.java;/*出现线程安全问他的解决方法：当一个线程a在操作ticket的时候，其他线程不能参与进来，直到线程参与进来，也操作完
    
                    
    • 
                    
  • 庖丁解java(一篇文章学java)
                        庖丁解java
java开发语言
                        
    (大家不用收藏这篇文章,因为这篇文章会经常更新,也就是删除后重发)一篇文章学java,这是我滴一个执念...当然,真一篇文章就写完java基础,java架构,java业务实现,java业务扩展,根本不可能.所以,这篇文章,就是一个索引,索什么呢?请看下文.关于决定开始写博文的介绍(一切故事的起点源于这一次反省)中小技术公司的软扩展(微服务扩展是否有必要?)-CSDN博客SpringCloud(一个
    
                    
    • 
                    
  • Java基础 -- 05反射reflect
                        mmlz00
Java基础Java基础反射reflectProxy动态代理
                        
    目录引序说不通1：注解说不通2：匿名内部类说不通3：动态代理反射：反射定义强调：类对象又强调：static类静态成员再三强调：synchronized修饰符类对象：知晓类结构类结构之：内部成员内部成员--构造函数内部成员--数据成员内部成员--方法成员静态代理：动态代理：反射+注解反射+泛型+注解getGenericSuperclass()用法引序引序：开始反射概念学习之前，先来段引序。请牢记：计
    
                    
    • 
                    
  • 从零开始学习Java的100个课程
                        陈在天box
java大数据开发语言
                        
    哈喽大家好，今天给大家推荐的是从零开始学习Java的100个课程，接下来我会每天更新两篇课程经验供大家参考学习；以下是为大家设计的从零开始学习Java的100个课程：一、Java基础语法Java开发环境搭建安装JDK配置环境变量编写并运行第一个Java程序基本数据类型整数类型（byte、short、int、long）浮点类型（float、double）字符类型（char）布尔类型（boolean）
    
                    
    • 
                    
  • java基础知识
                        阿拉伯的劳伦斯292
java开发语言
                        
    1.java简介跨平台性：Java语言的“一次编写，到处运行”特性是这一语言的重要优势,java程序编译成字节码，可以在安装了Java虚拟机（JVM，javavirtualmachine）的不同操作系统上运行面向对象：java是一门完全的面向对象编程语言，支持继承，抽象，封装和多态的特性内存管理：java通过垃圾回收器（GarbageCollector）自动管理内存，这就不用开发者手动释放内存了，
    
                    
    • 
                    
  • 2025届美团秋招笔试题
                        今天不coding
python算法开发语言
                        
    题型及时间90分钟单选10+算法3单选包括Java基础八股文、设计模式、计算机网络、sql语句算法1题目描述小美准备登录美团，需要输入密码，小美忘记了密码,只记得密码可能是n个字符串中的一个。小美会按照密码的长度从小到大依次尝试每个字符串，对于相同长度的字符串，小美随机尝试，并且相同的密码只会尝试一次。小美想知道，她最少需要尝试多少次才能登录成功，最多需要尝试多少次才能登录成功。小美不会重新尝试已
    
                    
    • 
                    
  • gee mysql数据库_MySQL
                        weixin_39955142
geemysql数据库
                        
    集合如果你有更好的想法请在评论区留下您的答案，一起交流讨论说说常见的集合有哪些？答：主要分List、Set、Map、Queue四类，其中包含ArrayList、LinkedList、HashSet、TreeSet、HashMapComparable和Comparator接口的区别？答：其两...»smart-rick2021-02-15JAVA基础面向对象有哪些特征？答：继承、封装、多态JDK与J
    
                    
    • 
                    
  • 2019-03-26Day02 java基础语法01
                        summericy

                        
    Day02java基础语法1.关键字：被Java语言赋予特殊含义的单词特点：字母小写注意void是一种特殊的数据类型（空类型）标识符:给类，接口，方法，变量起名字使用的序列组成:大小写，数字下划线_美元符号$特点;1.不以数字开头2.不能是Java关键字3.严格区分大小写最好见名知义常见规则包（其实就是文件夹，解决相同类名）划分命名空间，包名+类名单级:全部小写多级：全部小写且域名要反转类和接口一
    
                    
    • 
                                
  • Enum 枚举
                                    120153216
enum枚举
                                    
    原文地址：http://www.cnblogs.com/Kavlez/p/4268601.html Enumeration 
于Java 1.5增加的enum type...enum type是由一组固定的常量组成的类型，比如四个季节、扑克花色。在出现enum type之前，通常用一组int常量表示枚举类型。比如这样： 
public static final int APPLE_FUJI = 0
    
                                
    • 
                                
  • Java8简明教程
                                    bijian1013
javajdk1.8
                                    
            Java 8已于2014年3月18日正式发布了，新版本带来了诸多改进，包括Lambda表达式、Streams、日期时间API等等。本文就带你领略Java 8的全新特性。  
一.允许在接口中有默认方法实现 
        Java 8 允许我们使用default关键字，为接口声明添
    
                                
    • 
                                
  • Oracle表维护 快速备份删除数据
                                    cuisuqiang
oracle索引快速备份删除
                                    
    我知道oracle表分区，不过那是数据库设计阶段的事情，目前是远水解不了近渴。 
当前的数据库表，要求保留一个月数据，且表存在大量录入更新，不存在程序删除。 
为了解决频繁查询和更新的瓶颈，我在oracle内根据需要创建了索引。但是随着数据量的增加，一个半月数据就要超千万，此时就算有索引，对高并发的查询和更新来说，让然有所拖累。 
为了解决这个问题，我一般一个月会进行一次数据库维护，主要工作就是备
    
                                
    • 
                                
  • java多态内存分析
                                    麦田的设计者
java内存分析多态原理接口和抽象类
                                    
          “  时针如果可以回头，熟悉那张脸，重温嬉戏这乐园，墙壁的松脱涂鸦已经褪色才明白存在的价值归于记忆。街角小店尚存在吗？这大时代会不会牵挂，过去现在花开怎么会等待。 
      但有种意外不管痛不痛都有伤害，光阴远远离开，那笑声徘徊与脑海。但这一秒可笑不再可爱，当天心
    
                                
    • 
                                
  • Xshell实现Windows上传文件到Linux主机
                                    被触发
windows
                                    
    经常有这样的需求，我们在Windows下载的软件包，如何上传到远程Linux主机上？还有如何从Linux主机下载软件包到Windows下；之前我的做法现在看来好笨好繁琐，不过也达到了目的，笨人有本方法嘛； 
我是怎么操作的： 
1、打开一台本地Linux虚拟机，使用mount 挂载Windows的共享文件夹到Linux上，然后拷贝数据到Linux虚拟机里面；（经常第一步都不顺利，无法挂载Windo
    
                                
    • 
                                
  • 类的加载ClassLoader
                                    肆无忌惮_
ClassLoader
                                    
    类加载器ClassLoader是用来将java的类加载到虚拟机中，类加载器负责读取class字节文件到内存中，并将它转为Class的对象（类对象），通过此实例的 newInstance()方法就可以创建出该类的一个对象。 
  
其中重要的方法为findClass(String name)。 
  
如何写一个自己的类加载器呢？ 
首先写一个便于测试的类Student
    
                                
    • 
                                
  • html5写的玫瑰花
                                    知了ing
html5
                                    
    <html>  
<head>  
<title>I Love You!</title>  
<meta charset="utf-8" />  
</head>  
<body>  
<canvas id="c"></canvas>  

    
                                
    • 
                                
  • google的ConcurrentLinkedHashmap源代码解析
                                    矮蛋蛋
LRU
                                    
    原文地址： 
http://janeky.iteye.com/blog/1534352 
简述 
ConcurrentLinkedHashMap 是google团队提供的一个容器。它有什么用呢？其实它本身是对 
 
ConcurrentHashMap的封装，可以用来实现一个基于LRU策略的缓存。详细介绍可以参见 
 
http://code.google.com/p/concurrentlinke
    
                                
    • 
                                
  • webservice获取访问服务的ip地址
                                    alleni123
webservice
                                    
    1. 首先注入javax.xml.ws.WebServiceContext, 
@Resource 
 private WebServiceContext context; 
 
 
2. 在方法中获取交换请求的对象。 
 
 
javax.xml.ws.handler.MessageContext mc=context.getMessageContext();
com.sun.net.http
    
                                
    • 
                                
  • 菜鸟的java基础提升之道——————>是否值得拥有
                                    百合不是茶

                                    
    1，c++，java是面向对象编程的语言，将万事万物都看成是对象；java做一件事情关注的是人物，java是c++继承过来的，java没有直接更改地址的权限但是可以通过引用来传值操作地址，java也没有c++中繁琐的操作，java以其优越的可移植型，平台的安全型，高效性赢得了广泛的认同，全世界越来越多的人去学习java，我也是其中的一员 
  
  
 java组成：
    
                                
    • 
                                
  • 通过修改Linux服务自动启动指定应用程序
                                    bijian1013
linux
                                    
    Linux中修改系统服务的命令是chkconfig (check config)，命令的详细解释如下:  chkconfig

功能说明：检查，设置系统的各种服务。

语　　法：chkconfig [ -- add][ -- del][ -- list][系统服务] 或 chkconfig [ -- level  <</SPAN>
    
                                
    • 
                                
  • spring拦截器的一个简单实例
                                    bijian1013
javaspring拦截器Interceptor
                                    
    Purview接口 
package aop;

public interface Purview {
    void checkLogin();
} 
Purview接口的实现类PurviesImpl.java 
package aop;

public class PurviewImpl implements Purview {
	
    public void check
    
                                
    • 
                                
  • [Velocity二]自定义Velocity指令
                                    bit1129
velocity
                                    
    什么是Velocity指令 
在Velocity中，#set,#if, #foreach, #elseif, #parse等，以#开头的称之为指令，Velocity内置的这些指令可以用来做赋值，条件判断，循环控制等脚本语言必备的逻辑控制等语句，Velocity的指令是可扩展的，即用户可以根据实际的需要自定义Velocity指令 
  自定义指令(Directive)的一般步骤 
&nbs
    
                                
    • 
                                
  • 【Hive十】Programming Hive学习笔记
                                    bit1129
programming
                                    
     第二章 Getting Started 
1.Hive最大的局限性是什么？一是不支持行级别的增删改(insert, delete, update)二是查询性能非常差(基于Hadoop MapReduce）,不适合延迟小的交互式任务三是不支持事务2. Hive MetaStore是干什么的？Hive persists table schemas and other system metadata.
    
                                
    • 
                                
  • nginx有选择性进行限制
                                    ronin47
nginx 动静　限制
                                    
    http {
    limit_conn_zone $binary_remote_addr zone=addr:10m;
    limit_req_zone $binary_remote_addr zone=one:10m rate=5r/s;...

    server {...
       location ~.*\.(gif|png|css|js|icon)$ {
   
    
                                
    • 
                                
  • java-4.-在二元树中找出和为某一值的所有路径 .
                                    bylijinnan
java
                                    
    
/*
	 * 0.use a TwoWayLinkedList to store the path.when the node can't be path,you should/can delete it.
	 * 1.curSum==exceptedSum:if the lastNode is TreeNode,printPath();delete the node otherwise

    
                                
    • 
                                
  • Netty学习笔记
                                    bylijinnan
javanetty
                                    
    本文是阅读以下两篇文章时： 
 
http://seeallhearall.blogspot.com/2012/05/netty-tutorial-part-1-introduction-to.html 
 
http://seeallhearall.blogspot.com/2012/06/netty-tutorial-part-15-on-channel.html 
我的一些笔记 
 
===
    
                                
    • 
                                
  • js获取项目路径
                                    cngolon
js
                                    
    //js获取项目根路径，如： http://localhost:8083/uimcardprj 
function getRootPath(){ 
    //获取当前网址，如： http://localhost:8083/uimcardprj/share/meun.jsp 
    var curWwwPath=window.document.locati
    
                                
    • 
                                
  • oracle 的性能优化
                                    cuishikuan
oracleSQL Server
                                    
       在网上搜索了一些Oracle性能优化的文章，为了更加深层次的巩固[边写边记]，也为了可以随时查看，所以发表这篇文章。 
    1.ORACLE采用自下而上的顺序解析WHERE子句，根据这个原理，表之间的连接必须写在其他WHERE条件之前，那些可以过滤掉最大数量记录的条件必须写在WHERE子句的末尾。（这点本人曾经做过实例验证过，的确如此哦！
    
                                
    • 
                                
  • Shell变量和数组使用详解
                                    daizj
linuxshell变量数组
                                    
    Shell 变量 
定义变量时，变量名不加美元符号（$，PHP语言中变量需要），如： 
your_name="w3cschool.cc" 
注意，变量名和等号之间不能有空格，这可能和你熟悉的所有编程语言都不一样。同时，变量名的命名须遵循如下规则： 
 
 首个字符必须为字母（a-z，A-Z）。 
 中间不能有空格，可以使用下划线（_）。 
 不能使用标点符号。 
 不能使用ba
    
                                
    • 
                                
  • 编程中的一些概念，KISS、DRY、MVC、OOP、REST
                                    dcj3sjt126com
REST
                                    
    KISS、DRY、MVC、OOP、REST （1）KISS是指Keep It Simple,Stupid（摘自wikipedia），指设计时要坚持简约原则，避免不必要的复杂化。 （2）DRY是指Don't Repeat Yourself（摘自wikipedia），特指在程序设计以及计算中避免重复代码，因为这样会降低灵活性、简洁性，并且可能导致代码之间的矛盾。 （3）OOP 即Object-Orie
    
                                
    • 
                                
  • [Android]设置Activity为全屏显示的两种方法
                                    dcj3sjt126com
Activity
                                    
    1. 方法1：AndroidManifest.xml 里，Activity的 android:theme  指定为" @android:style/Theme.NoTitleBar.Fullscreen" 示例:   <application      
    
                                
    • 
                                
  • solrcloud 部署方式比较
                                    eksliang
solrCloud
                                    
    solrcloud 的部署其实有两种方式可选，那么我们在实践开发中应该怎样选择呢？ 第一种：当启动solr服务器时，内嵌的启动一个Zookeeper服务器，然后将这些内嵌的Zookeeper服务器组成一个集群。  第二种：将Zookeeper服务器独立的配置一个集群，然后将solr交给Zookeeper进行管理 
  
谈谈第一种：每启动一个solr服务器就内嵌的启动一个Zoo
    
                                
    • 
                                
  • Java synchronized关键字详解
                                    gqdy365
synchronized
                                    
    转载自：http://www.cnblogs.com/mengdd/archive/2013/02/16/2913806.html 
 
多线程的同步机制对资源进行加锁，使得在同一个时间，只有一个线程可以进行操作，同步用以解决多个线程同时访问时可能出现的问题。 
同步机制可以使用synchronized关键字实现。 
当synchronized关键字修饰一个方法的时候，该方法叫做同步方法。 
当s
    
                                
    • 
                                
  • js实现登录时记住用户名
                                    hw1287789687
记住我记住密码cookie记住用户名记住账号
                                    
    在页面中如何获取cookie值呢? 
如果是JSP的话,可以通过servlet的对象request 获取cookie,可以 
参考:http://hw1287789687.iteye.com/blog/2050040 
如果要求登录页面是html呢?html页面中如何获取cookie呢? 
直接上代码了 
页面:loginInput.html 
代码: 
<!DOCTYPE html PUB
    
                                
    • 
                                
  • 开发者必备的 Chrome 扩展
                                    justjavac
chrome
                                    
    Firebug：不用多介绍了吧https://chrome.google.com/webstore/detail/bmagokdooijbeehmkpknfglimnifench 
ChromeSnifferPlus：Chrome 探测器，可以探测正在使用的开源软件或者 js 类库https://chrome.google.com/webstore/detail/chrome-sniffer-pl
    
                                
    • 
                                
  • 算法机试题
                                    李亚飞
java算法机试题
                                    
           在面试机试时，遇到一个算法题，当时没能写出来，最后是同学帮忙解决的。 
       这道题大致意思是：输入一个数，比如4,。这时会输出： 
          &n
    
                                
    • 
                                
  • 正确配置Linux系统ulimit值
                                    字符串
ulimit
                                    
    在Linux下面部 署应用的时候，有时候会遇上Socket/File: Can’t open so many files的问题；这个值也会影响服务器的最大并发数，其实Linux是有文件句柄限制的，而且Linux默认不是很高，一般都是1024，生产服务器用 其实很容易就达到这个数量。下面说的是，如何通过正解配置来改正这个系统默认值。因为这个问题是我配置Nginx+php5时遇到了，所以我将这篇归纳进
    
                                
    • 
                                
  • hibernate调用返回游标的存储过程
                                    Supanccy2013
javaDAOoracleHibernatejdbc
                                    
    注：原创作品，转载请注明出处。 
 
 
    上篇博文介绍的是hibernate调用返回单值的存储过程，本片博文说的是hibernate调用返回游标的存储过程。 
    此此扁博文的存储过程的功能相当于是jdbc调用select 的作用。 
 
1，创建oracle中的包，并在该包中创建的游标类型。 
 
---创建oracle的程
    
                                
    • 
                                
  • Spring 4.2新特性-更简单的Application Event
                                    wiselyman
application
                                    
    1.1 Application Event 
 
  Spring 4.1的写法请参考10点睛Spring4.1-Application Event  
  请对比10点睛Spring4.1-Application Event  
  使用一个@EventListener取代了实现ApplicationListener接口,使耦合度降低;  
  
1.2 示例 
 
 包依赖 
  
<p
    
                                
    •