javase 高级 （回忆章）

java 高级教程

数据结构

Java工具包提供了强大的数据结构。在Java中的数据结构主要包括以下几种接口和类：

  • 枚举（Enumeration）

    枚举（Enumeration）接口虽然它本身不属于数据结构,但它在其他数据结构的范畴里应用很广。 枚举（The Enumeration）接口定义了一种从数据结构中取回连续元素的方式。

  • 位集合（BitSet）

    位集合类实现了一组可以单独设置和清除的位或标志。

  • 向量（Vector）

    向量（Vector）类和传统数组非常相似，但是Vector的大小能根据需要动态的变化。

    和数组一样，Vector对象的元素也能通过索引访问。

  • 栈（Stack）

    栈（Stack）实现了一个后进先出（LIFO）的数据结构。

  • 字典（Dictionary）

    字典（Dictionary） 类是一个抽象类，它定义了键映射到值的数据结构。

  • 哈希表（Hashtable）

    Hashtable类提供了一种在用户定义键结构的基础上来组织数据的手段。

  • 属性（Properties）

    Properties 继承于 Hashtable.Properties 类表示了一个持久的属性集.属性列表中每个键及其对应值都是一个字符串。

集合框架

集合算法

集合框架定义了几种算法，可用于集合和映射。这些算法被定义为集合类的静态方法

遍历 ArrayList

public static void main(String[] args) {
    List<String> list=new ArrayList<String>();
    list.add("Hello");
    list.add("World");
    list.add("HAHAHAHA");
    //第一种遍历方法使用 For-Each 遍历 List
    for (String str : list) {            //也可以改写 for(int i=0;i<list.size();i++) 这种形式
        System.out.println(str);
    }
 
    //第二种遍历，把链表变为数组相关的内容进行遍历
    String[] strArray=new String[list.size()];
    list.toArray(strArray);
    for(int i=0;i<strArray.length;i++) //这里也可以改写为  for(String str:strArray) 这种形式
    {
        System.out.println(strArray[i]);
    }
 
    //第三种遍历 使用迭代器进行相关遍历
 
    Iterator<String> ite=list.iterator();
    while(ite.hasNext())//判断下一个元素之后有值
    {
        System.out.println(ite.next());
    }
}

遍历 Map

public static void main(String[] args) {
    Map<String, String> map = new HashMap<String, String>();
    map.put("1", "value1");
    map.put("2", "value2");
    map.put("3", "value3");
 
    //第一种：普遍使用，二次取值
    System.out.println("通过Map.keySet遍历key和value：");
    for (String key : map.keySet()) {
        System.out.println("key= "+ key + " and value= " + map.get(key));
    }
 
    //第二种
    System.out.println("通过Map.entrySet使用iterator遍历key和value：");
    Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
    while (it.hasNext()) {
        Map.Entry<String, String> entry = it.next();
        System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
    }
 
    //第三种：推荐，尤其是容量大时
    System.out.println("通过Map.entrySet遍历key和value");
    for (Map.Entry<String, String> entry : map.entrySet()) {
        System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
    }
 
    //第四种
    System.out.println("通过Map.values()遍历所有的value，但不能遍历key");
    for (String v : map.values()) {
        System.out.println("value= " + v);
    }
}

Java集合框架为程序员提供了预先包装的数据结构和算法来操纵他们。

集合是一个对象，可容纳其他对象的引用。集合接口声明对每一种类型的集合可以执行的操作。

集合框架的类和接口均在java.util包中。

任何对象加入集合类后，自动转变为Object类型，所以在取出的时候，需要进行强制类型转换。

ArrayList

ArrayList 是一个数组队列，提供了相关的添加、删除、修改、遍历等功能。

添加元素

public static void main(String[] args) {
    ArrayList<String> sites = new ArrayList<String>();
    sites.add("Google");
    sites.add("Runoob");
    sites.add("Taobao");
    sites.add("Weibo");
    System.out.println(sites);
}

修改元素

public static void main(String[] args) {
    ArrayList<String> sites = new ArrayList<String>();
    sites.add("Google");
    sites.add("Runoob");
    sites.add("Taobao");
    sites.add("Weibo");
    sites.set(2, "Wiki"); // 第一个参数为索引位置，第二个为要修改的值
    System.out.println(sites);
}

删除元素

public static void main(String[] args) {
    ArrayList<String> sites = new ArrayList<String>();
    sites.add("Google");
    sites.add("Runoob");
    sites.add("Taobao");
    sites.add("Weibo");
    sites.remove(3); // 删除第四个元素
    System.out.println(sites);
}

计算大小

public static void main(String[] args) {
    ArrayList<String> sites = new ArrayList<String>();
    sites.add("Google");
    sites.add("Runoob");
    sites.add("Taobao");
    sites.add("Weibo");
    System.out.println(sites.size());
}

迭代数组列表

public static void main(String[] args) {
    ArrayList<String> sites = new ArrayList<String>();
    sites.add("Google");
    sites.add("Runoob");
    sites.add("Taobao");
    sites.add("Weibo");
    for (int i = 0; i < sites.size(); i++) {
        System.out.println(sites.get(i));
    }
}
public static void main(String[] args) {
    ArrayList<String> sites = new ArrayList<String>();
    sites.add("Google");
    sites.add("Runoob");
    sites.add("Taobao");
    sites.add("Weibo");
    for (String i : sites) {
        System.out.println(i);
    }
}

排序

public static void main(String[] args) {
    ArrayList<String> sites = new ArrayList<String>();
    sites.add("Taobao");
    sites.add("Wiki");
    sites.add("Runoob");
    sites.add("Weibo");
    sites.add("Google");
    Collections.sort(sites);  // 字母排序
    for (String i : sites) {
        System.out.println(i);
    }
}

Java LinkedList

链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址

LinkedList 的增加和删除的操作效率更高，而查找和修改的操作效率较低

LinkedList 继承了 AbstractSequentialList 类。

LinkedList 实现了 Queue 接口，可作为队列使用。

LinkedList 实现了 List 接口，可进行列表的相关操作。

LinkedList 实现了 Deque 接口，可作为队列使用。

LinkedList 实现了 Cloneable 接口，可实现克隆。

LinkedList 实现了 java.io.Serializable 接口，即可支持序列化，能通过序列化去传输。

public static void main(String[] args) {
    LinkedList<String> sites = new LinkedList<String>();
    sites.add("Google");
    sites.add("Runoob");
    sites.add("Taobao");
    sites.add("Weibo");
    System.out.println(sites);
}
public static void main(String[] args) {
    LinkedList<String> sites = new LinkedList<String>();
    sites.add("Google");
    sites.add("Runoob");
    sites.add("Taobao");
    // 使用 addLast() 在尾部添加元素
    sites.addLast("Wiki");
    System.out.println(sites);
}
public static void main(String[] args) {
    LinkedList<String> sites = new LinkedList<String>();
    sites.add("Google");
    sites.add("Runoob");
    sites.add("Taobao");
    sites.add("Weibo");
    // 使用 removeFirst() 移除头部元素
    sites.removeFirst();
    System.out.println(sites);
}
public static void main(String[] args) {
    LinkedList<String> sites = new LinkedList<String>();
    sites.add("Google");
    sites.add("Runoob");
    sites.add("Taobao");
    sites.add("Weibo");
    // 使用 removeLast() 移除尾部元素
    sites.removeLast();
    System.out.println(sites);
}
public static void main(String[] args) {
    LinkedList<String> sites = new LinkedList<String>();
    sites.add("Google");
    sites.add("Runoob");
    sites.add("Taobao");
    sites.add("Weibo");
    // 使用 getFirst() 获取头部元素
    System.out.println(sites.getFirst());
}
public static void main(String[] args) {
    LinkedList<String> sites = new LinkedList<String>();
    sites.add("Google");
    sites.add("Runoob");
    sites.add("Taobao");
    sites.add("Weibo");
    // 使用 getLast() 获取尾部元素
    System.out.println(sites.getLast());
}

for 配合 size() 方法来迭代列表中的元素

public static void main(String[] args) {
    LinkedList<String> sites = new LinkedList<String>();
    sites.add("Google");
    sites.add("Runoob");
    sites.add("Taobao");
    sites.add("Weibo");
    for (int size = sites.size(), i = 0; i < size; i++) {
        System.out.println(sites.get(i));
    }
}

使用 for-each 来迭代元素

public static void main(String[] args) {
    LinkedList<String> sites = new LinkedList<String>();
    sites.add("Google");
    sites.add("Runoob");
    sites.add("Taobao");
    sites.add("Weibo");
    for (String i : sites) {
        System.out.println(i);
    }
}

Java HashSet

HashSet 基于 HashMap 来实现的，是一个不允许有重复元素的集合。

HashSet 允许有 null 值。

HashSet 是无序的，即不会记录插入的顺序。

HashSet 不是线程安全的， 如果多个线程尝试同时修改 HashSet，则最终结果是不确定的。 您必须在多线程访问时显式同步对 HashSet 的并发访问。

HashSet 中的元素实际上是对象，一些常见的基本类型可以使用它的包装类

添加元素

public static void main(String[] args) {
    HashSet<String> sites = new HashSet<String>();
    sites.add("Google");
    sites.add("Runoob");
    sites.add("Taobao");
    sites.add("Zhihu");
    sites.add("Runoob");  // 重复的元素不会被添加
    System.out.println(sites);
}

判断元素是否存在

public static void main(String[] args) {
    HashSet<String> sites = new HashSet<String>();
    sites.add("Google");
    sites.add("Runoob");
    sites.add("Taobao");
    sites.add("Zhihu");
    sites.add("Runoob");  // 重复的元素不会被添加
    System.out.println(sites.contains("Taobao"));
}

删除元素

public static void main(String[] args) {
    HashSet<String> sites = new HashSet<String>();
    sites.add("Google");
    sites.add("Runoob");
    sites.add("Taobao");
    sites.add("Zhihu");
    sites.add("Runoob");     // 重复的元素不会被添加
    sites.remove("Taobao");  // 删除元素，删除成功返回 true，否则为 false
    System.out.println(sites);
}

删除集合中所有元素

public static void main(String[] args) {
    HashSet<String> sites = new HashSet<String>();
    sites.add("Google");
    sites.add("Runoob");
    sites.add("Taobao");
    sites.add("Zhihu");
    sites.add("Runoob");     // 重复的元素不会被添加
    sites.clear();
    System.out.println(sites);
}

计算大小

public static void main(String[] args) {
    HashSet<String> sites = new HashSet<String>();
    sites.add("Google");
    sites.add("Runoob");
    sites.add("Taobao");
    sites.add("Zhihu");
    sites.add("Runoob");     // 重复的元素不会被添加
    System.out.println(sites.size());
}

迭代 HashSet

public static void main(String[] args) {
    HashSet<String> sites = new HashSet<String>();
    sites.add("Google");
    sites.add("Runoob");
    sites.add("Taobao");
    sites.add("Zhihu");
    sites.add("Runoob");     // 重复的元素不会被添加
    for (String i : sites) {
        System.out.println(i);
    }
}

java HashMap

HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。

HashMap 实现了 Map 接口，根据键的 HashCode 值存储数据，具有很快的访问速度，最多允许一条记录的键为 null，不支持线程同步。

HashMap 是无序的，即不会记录插入的顺序。

添加元素

public static void main(String[] args) {
    // 创建 HashMap 对象 Sites
    HashMap<Integer, String> Sites = new HashMap<Integer, String>();
    // 添加键值对
    Sites.put(1, "Google");
    Sites.put(2, "Runoob");
    Sites.put(3, "Taobao");
    Sites.put(4, "Zhihu");
    System.out.println(Sites);
}
public static void main(String[] args) {
    // 创建 HashMap 对象 Sites
    HashMap<String, String> Sites = new HashMap<String, String>();
    // 添加键值对
    Sites.put("one", "Google");
    Sites.put("two", "Runoob");
    Sites.put("three", "Taobao");
    Sites.put("four", "Zhihu");
    System.out.println(Sites);
}

访问元素

public static void main(String[] args) {
    // 创建 HashMap 对象 Sites
    HashMap<Integer, String> Sites = new HashMap<Integer, String>();
    // 添加键值对
    Sites.put(1, "Google");
    Sites.put(2, "Runoob");
    Sites.put(3, "Taobao");
    Sites.put(4, "Zhihu");
    System.out.println(Sites.get(3));
}

删除元素

public static void main(String[] args) {
    // 创建 HashMap 对象 Sites
    HashMap<Integer, String> Sites = new HashMap<Integer, String>();
    // 添加键值对
    Sites.put(1, "Google");
    Sites.put(2, "Runoob");
    Sites.put(3, "Taobao");
    Sites.put(4, "Zhihu");
    Sites.remove(4);
    System.out.println(Sites);
}
public static void main(String[] args) {
    // 创建 HashMap 对象 Sites
    HashMap<Integer, String> Sites = new HashMap<Integer, String>();
    // 添加键值对
    Sites.put(1, "Google");
    Sites.put(2, "Runoob");
    Sites.put(3, "Taobao");
    Sites.put(4, "Zhihu");
    Sites.clear();
    System.out.println(Sites);
}

计算大小

public static void main(String[] args) {
    // 创建 HashMap 对象 Sites
    HashMap<Integer, String> Sites = new HashMap<Integer, String>();
    // 添加键值对
    Sites.put(1, "Google");
    Sites.put(2, "Runoob");
    Sites.put(3, "Taobao");
    Sites.put(4, "Zhihu");
    System.out.println(Sites.size());
}

迭代 HashMap

public static void main(String[] args) {
    // 创建 HashMap 对象 Sites
    HashMap<Integer, String> Sites = new HashMap<Integer, String>();
    // 添加键值对
    Sites.put(1, "Google");
    Sites.put(2, "Runoob");
    Sites.put(3, "Taobao");
    Sites.put(4, "Zhihu");
    // 输出 key 和 value
    for (Integer i : Sites.keySet()) {
        System.out.println("key: " + i + " value: " + Sites.get(i));
    }
    // 返回所有 value 值
    for(String value: Sites.values()) {
        // 输出每一个value
        System.out.print(value + ", ");
    }
}

Java Iterator

迭代器 it 的两个基本操作是 next 、hasNext 和 remove。

调用 it.next() 会返回迭代器的下一个元素，并且更新迭代器的状态。

调用 it.hasNext() 用于检测集合中是否还有元素。

调用 it.remove() 将迭代器返回的元素删除。

获取一个迭代器

public static void main(String[] args) {
 
    // 创建集合
    ArrayList<String> sites = new ArrayList<String>();
    sites.add("Google");
    sites.add("Runoob");
    sites.add("Taobao");
    sites.add("Zhihu");
 
    // 获取迭代器
    Iterator<String> it = sites.iterator();
 
    // 输出集合中的第一个元素
    System.out.println(it.next());
}

循环集合元素

public static void main(String[] args) {
 
    // 创建集合
    ArrayList<String> sites = new ArrayList<String>();
    sites.add("Google");
    sites.add("Runoob");
    sites.add("Taobao");
    sites.add("Zhihu");
 
    // 获取迭代器
    Iterator<String> it = sites.iterator();
 
    // 输出集合中的所有元素
    while(it.hasNext()) {
        System.out.println(it.next());
    }
}

删除元素

public static void main(String[] args) {
    ArrayList<Integer> numbers = new ArrayList<Integer>();
    numbers.add(12);
    numbers.add(8);
    numbers.add(2);
    numbers.add(23);
    Iterator<Integer> it = numbers.iterator();
    while(it.hasNext()) {
        Integer i = it.next();
        if(i < 10) {
            it.remove();  // 删除小于 10 的元素
        }
    }
    System.out.println(numbers);
}

Java Object 类

任何类的祖宗类

Java 泛型

泛型方法

  • E - Element (在集合中使用，因为集合中存放的是元素)
  • T - Type（Java 类）
  • K - Key（键）
  • V - Value（值）
  • N - Number（数值类型）
  • ？ - 表示不确定的 java 类型
// 泛型方法 printArray
public static < E > void printArray( E[] inputArray )
{
    // 输出数组元素
    for ( E element : inputArray ){
        System.out.printf( "%s ", element );
    }
    System.out.println();
}
 
public static void main( String args[] )
{
    // 创建不同类型数组： Integer, Double 和 Character
    Integer[] intArray = { 1, 2, 3, 4, 5 };
    Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
    Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };
 
    System.out.println( "整型数组元素为:" );
    printArray( intArray  ); // 传递一个整型数组
 
    System.out.println( "\n双精度型数组元素为:" );
    printArray( doubleArray ); // 传递一个双精度型数组
 
    System.out.println( "\n字符型数组元素为:" );
    printArray( charArray ); // 传递一个字符型数组
}
// 比较三个值并返回最大值
public static <T extends Comparable<T>> T maximum(T x, T y, T z)
{
    T max = x; // 假设x是初始最大值
    if ( y.compareTo( max ) > 0 ){
        max = y; //y 更大
    }
    if ( z.compareTo( max ) > 0 ){
        max = z; // 现在 z 更大
    }
    return max; // 返回最大对象
}
public static void main( String args[] )
{
    System.out.printf( "%d, %d 和 %d 中最大的数为 %d\n\n",
            3, 4, 5, maximum( 3, 4, 5 ) );
 
    System.out.printf( "%.1f, %.1f 和 %.1f 中最大的数为 %.1f\n\n",
            6.6, 8.8, 7.7, maximum( 6.6, 8.8, 7.7 ) );
 
    System.out.printf( "%s, %s 和 %s 中最大的数为 %s\n","pear",
            "apple", "orange", maximum( "pear", "apple", "orange" ) );
}

泛型类

class Box<T> {
 
    private T t;
 
    public void add(T t) {
        this.t = t;
    }
 
    public T get() {
        return t;
    }
 
    public static void main(String[] args) {
        Box<Integer> integerBox = new Box<Integer>();
        Box<String> stringBox = new Box<String>();
 
        integerBox.add(new Integer(10));
        stringBox.add(new String("菜鸟教程"));
 
        System.out.printf("整型值为 :%d\n\n", integerBox.get());
        System.out.printf("字符串为 :%s\n", stringBox.get());
    }
}

类型通配符

class GenericTest {
 
    public static void main(String[] args) {
        List<String> name = new ArrayList<String>();
        List<Integer> age = new ArrayList<Integer>();
        List<Number> number = new ArrayList<Number>();
 
        name.add("icon");
        age.add(18);
        number.add(314);
 
        getData(name);
        getData(age);
        getData(number);
 
    }
 
    public static void getData(List<?> data) {
        System.out.println("data :" + data.get(0));
    }
}

Java 序列化

一个对象可以被表示为一个字节序列，该字节序列包括该对象的数据、有关对象的类型的信息和存储在对象中数据的类型。

网络编程

网络编程是指编写运行在多个设备（计算机）的程序，这些设备都通过网络连接起来。

Socket 编程

套接字使用TCP提供了两台计算机之间的通信机制

连接建立后，通过使用 I/O 流在进行通信，每一个socket都有一个输出流和一个输入流，客户端的输出流连接到服务器端的输入流，而客户端的输入流连接到服务器端的输出流

Java 多线程编程

Java 给多线程编程提供了内置的支持。 一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

多线程能满足程序员编写高效率的程序来达到充分利用 CPU 的目的。

一个线程的生命周期

  • 新建状态:

    使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序 start() 这个线程。

  • 就绪状态:

    当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。

  • 运行状态:

    如果就绪状态的线程获取 CPU 资源，就可以执行 run()，此时线程便处于运行状态。处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。

  • 阻塞状态:

    如果一个线程执行了sleep（睡眠）、suspend（挂起）等方法，失去所占用资源之后，该线程就从运行状态进入阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态。可以分为三种：

    • 等待阻塞：运行状态中的线程执行 wait() 方法，使线程进入到等待阻塞状态。
    • 同步阻塞：线程在获取 synchronized 同步锁失败(因为同步锁被其他线程占用)。
    • 其他阻塞：通过调用线程的 sleep() 或 join() 发出了 I/O 请求时，线程就会进入到阻塞状态。当sleep() 状态超时，join() 等待线程终止或超时，或者 I/O 处理完毕，线程重新转入就绪状态。

  • 死亡状态:

    一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态。

线程的优先级

每一个 Java 线程都有一个优先级

具有较高优先级的线程对程序更重要，并且应该在低优先级的线程之前分配处理器资源。但是，线程优先级不能保证线程执行的顺序，而且非常依赖于平台。

创建一个线程

Java 提供了三种创建线程的方法：

  • 通过实现 Runnable 接口；
  • 通过继承 Thread 类本身；
  • 通过 Callable 和 Future 创建线程。

通过实现 Runnable 接口来创建线程

class RunnableDemo implements Runnable {
    private Thread t;
    private String threadName;
 
    RunnableDemo( String name) {
        threadName = name;
        System.out.println("Creating " +  threadName );
    }
 
    public void run() {
        System.out.println("Running " +  threadName );
        try {
            for(int i = 4; i > 0; i--) {
                System.out.println("Thread: " + threadName + ", " + i);
                // 让线程睡眠一会
                Thread.sleep(50);
            }
        }catch (InterruptedException e) {
            System.out.println("Thread " +  threadName + " interrupted.");
        }
        System.out.println("Thread " +  threadName + " exiting.");
    }
 
    public void start () {
        System.out.println("Starting " +  threadName );
        if (t == null) {
            t = new Thread (this, threadName);
            t.start ();
        }
    }
}
 
public class TestThread {
 
    public static void main(String args[]) {
        RunnableDemo R1 = new RunnableDemo( "Thread-1");
        R1.start();
 
        RunnableDemo R2 = new RunnableDemo( "Thread-2");
        R2.start();
    }
}

通过继承Thread来创建线程

class ThreadDemo extends Thread {
    private Thread t;
    private String threadName;
 
    ThreadDemo( String name) {
        threadName = name;
        System.out.println("Creating " +  threadName );
    }
 
    public void run() {
        System.out.println("Running " +  threadName );
        try {
            for(int i = 4; i > 0; i--) {
                System.out.println("Thread: " + threadName + ", " + i);
                // 让线程睡眠一会
                Thread.sleep(50);
            }
        }catch (InterruptedException e) {
            System.out.println("Thread " +  threadName + " interrupted.");
        }
        System.out.println("Thread " +  threadName + " exiting.");
    }
 
    public void start () {
        System.out.println("Starting " +  threadName );
        if (t == null) {
            t = new Thread (this, threadName);
            t.start ();
        }
    }
}
 
public class TestThread {
 
    public static void main(String args[]) {
        ThreadDemo T1 = new ThreadDemo( "Thread-1");
        T1.start();
 
        ThreadDemo T2 = new ThreadDemo( "Thread-2");
        T2.start();
    }
}

Callable 和 Future 创建线程

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
 
public class Main { }
class CallableThreadTest implements Callable<Integer> {
    public static void main(String[] args)
    {
        CallableThreadTest ctt = new CallableThreadTest();
        FutureTask<Integer> ft = new FutureTask<>(ctt);
        for(int i = 0;i < 100;i++)
        {
            System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i);
            if(i==20)
            {
                new Thread(ft,"有返回值的线程").start();
            }
        }
        try
        {
            System.out.println("子线程的返回值："+ft.get());
        } catch (InterruptedException e)
        {
            e.printStackTrace();
        } catch (ExecutionException e)
        {
            e.printStackTrace();
        }
    }
    
    @Override
    public Integer call() throws Exception
    {
        int i = 0;
        for(;i<100;i++)
        {
            System.out.println(Thread.currentThread().getName()+" "+i);
        }
        return i;
    }
}

创建线程的三种方式的对比

  • \1. 采用实现 Runnable、Callable 接口的方式创建多线程时，线程类只是实现了 Runnable 接口或 Callable 接口，还可以继承其他类。
  • \2. 使用继承 Thread 类的方式创建多线程时，编写简单，如果需要访问当前线程，则无需使用 Thread.currentThread() 方法，直接使用 this 即可获得当前线程。

线程的几个主要概念

在多线程编程时，你需要了解以下几个概念：

  • 线程同步
  • 线程间通信
  • 线程死锁
  • 线程控制：挂起、停止和恢复

Java Applet

Applet 是一种 Java 程序。它一般运行在支持 Java 的 Web 浏览器内。因为它有完整的 Java API支持,所以Applet 是一个全功能的 Java 应用程序。

Applet的生命周期

Applet 类中的四个方法给我们提供了一个框架，你可以在该框架上开发小程序：

  • init: 该方法的目的是为你的 Applet 提供所需的任何初始化。在 Applet 标记内的 param 标签被处理后调用该方法。
  • start: 浏览器调用 init 方法后，该方法被自动调用。每当用户从其他页面返回到包含 Applet 的页面时，则调用该方法。
  • stop: 当用户从包含 Applet 的页面移除的时候，该方法自动被调用。因此，可以在相同的 Applet 中反复调用该方法。
  • destroy: 此方法仅当浏览器正常关闭时调用。因为 Applet 只有在 HTML 网页上有效，所以你不应该在用户离开包含 Applet 的页面后遗漏任何资源。
  • paint: 该方法在 start() 方法之后立即被调用，或者在 Applet 需要重绘在浏览器的时候调用。paint() 方法实际上继承于 java.awt。

Java 文档注释

javadoc 标签

image-20220605203957391

/**
* 这个类演示了文档注释
* @author Ayan Amhed
* @version 1.2
*/

java 实例

超链接：Java 实例 | 菜鸟教程 (runoob.com)

java8 新特性

Java 8 (又称为 jdk 1.8) 是 Java 语言开发的一个主要版本

新特性

Java8 新增了非常多的特性，我们主要讨论以下几个：

  • Lambda 表达式 − Lambda 允许把函数作为一个方法的参数（函数作为参数传递到方法中）。
  • 方法引用 − 方法引用提供了非常有用的语法，可以直接引用已有Java类或对象（实例）的方法或构造器。与lambda联合使用，方法引用可以使语言的构造更紧凑简洁，减少冗余代码。
  • 默认方法 − 默认方法就是一个在接口里面有了一个实现的方法。
  • 新工具 − 新的编译工具，如：Nashorn引擎 jjs、 类依赖分析器jdeps。
  • Stream API −新添加的Stream API（java.util.stream） 把真正的函数式编程风格引入到Java中。
  • Date Time API − 加强对日期与时间的处理。
  • Optional 类 − Optional 类已经成为 Java 8 类库的一部分，用来解决空指针异常。
  • Nashorn, JavaScript 引擎 − Java 8提供了一个新的Nashorn javascript引擎，它允许我们在JVM上运行特定的javascript应用。

Lambda

public class Main {
    public static void main(String[] args) {
        List<String> names1 = new ArrayList<String>();
        names1.add("Google ");
        names1.add("Runoob ");
        names1.add("Taobao ");
        names1.add("Baidu ");
        names1.add("Sina ");
 
        new Main().sort(names1);
        for (String s : names1) {
            System.out.println(s);
        }
 
 
    }
    public void sort(List<String> names){
        Collections.sort(names,(s1,s2) -> s1.compareTo(s2));
    }
}
public static void main(String[] args) {
    Main tester = new Main();
    MathOperation addition = (int a,int b) -> a+b;
    MathOperation subtraction = (a,b) -> a-b;
    MathOperation multiplication = (a,b) -> {return a*b;};
    MathOperation division = (a,b) -> a/b;
 
    System.out.println("10 + 5 = " + tester.operate(10, 5, addition));
    System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction));
    System.out.println("10 x 5 = " + tester.operate(10, 5, multiplication));
    System.out.println("10 / 5 = " + tester.operate(10, 5, division));
 
    // 不用括号
    GreetingService greetService1 = message ->
    System.out.println("Hello " + message);
    greetService1.sayMessage("Runoob");
 
}
interface MathOperation {
    int operation(int a, int b);
}
interface GreetingService {
    void sayMessage(String message);
}
private int operate(int a, int b, MathOperation mathOperation){
    return mathOperation.operation(a, b);
}

使用 Lambda 表达式需要注意以下两点：

  • Lambda 表达式主要用来定义行内执行的方法类型接口，例如，一个简单方法接口。在上面例子中，我们使用各种类型的Lambda表达式来定义MathOperation接口的方法。然后我们定义了sayMessage的执行。
  • Lambda 表达式免去了使用匿名方法的麻烦，并且给予Java简单但是强大的函数化的编程能力。

变量作用域

lambda 表达式只能引用标记了 final 的外层局部变量，这就是说不能在 lambda 内部修改定义在域外的局部变量，否则会编译错误

方法引用

方法引用通过方法的名字来指向一个方法。

方法引用使用一对冒号 :: 。

public static void main(String[] args) {
    List<String> names = new ArrayList();
 
    names.add("Google");
    names.add("Runoob");
    names.add("Taobao");
    names.add("Baidu");
    names.add("Sina");
 
    names.forEach(System.out::println);
}

函数式接口

函数式接口(Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。

函数式接口可以被隐式转换为 lambda 表达式。

public class Main {
    public static void main(String[] args) {
        GreetingService greetService1 = message -> System.out.println("Hello " + message);
    }
}
@FunctionalInterface
interface GreetingService
{
    void sayMessage(String message);
}
public class Main {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
        System.out.println("输出所有数据:");
        eval(list, n->true);
 
        System.out.println("输出所有偶数:");
        eval(list, n-> n%2 == 0 );
 
        System.out.println("输出大于 3 的所有数字:");
        eval(list, n-> n > 3 );
 
    }
    public static void eval(List<Integer> list, Predicate<Integer> predicate) {
        for(Integer n: list) {
 
            if(predicate.test(n)) {
                System.out.println(n + " ");
            }
        }
    }
}

默认方法

默认方法就是接口可以有实现方法，而且不需要实现类去实现其方法。

我们只需在方法名前面加个 default 关键字即可实现默认方法

class Java8Tester {
    public static void main(String args[]){
        Vehicle vehicle = new Car();
        vehicle.print();
    }
}
 
interface Vehicle {
    default void print(){
        System.out.println("我是一辆车!");
    }
 
    static void blowHorn(){
        System.out.println("按喇叭!!!");
    }
}
 
interface FourWheeler {
    default void print(){
        System.out.println("我是一辆四轮车!");
    }
}
 
class Car implements Vehicle, FourWheeler {
    public void print(){
        Vehicle.super.print();
        FourWheeler.super.print();
        Vehicle.blowHorn();
        System.out.println("我是一辆汽车!");
    }
}

Stream

一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据

将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理

Stream（流）是一个来自数据源的元素队列并支持聚合操作

元素是特定类型的对象，形成一个队列

数据源 流的来源

聚合操作 类似SQL语句一样的操作

Pipelining: 中间操作都会返回流对象本身

内部迭代： 以前对集合遍历都是通过Iterator或者For-Each的方式, 显式的在集合外部进行迭代， 这叫做外部迭代。 Stream提供了内部迭代的方式， 通过访问者模式(Visitor)实现。

生成流

集合接口有两个方法来生成流：

  • stream() − 为集合创建串行流。
  • parallelStream() − 为集合创建并行流。

生成流

在 Java 8 中, 集合接口有两个方法来生成流：

  • stream() − 为集合创建串行流。
  • parallelStream() − 为集合创建并行流。

List strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl"); List filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());

forEach

Stream 提供了新的方法 'forEach' 来迭代流中的每个数据。以下代码片段使用 forEach 输出了10个随机数：

Random random = new Random(); random.ints().limit(10).forEach(System.out::println);

map

map 方法用于映射每个元素到对应的结果，以下代码片段使用 map 输出了元素对应的平方数：

List numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5); // 获取对应的平方数 List squaresList = numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList());

filter

filter 方法用于通过设置的条件过滤出元素。以下代码片段使用 filter 方法过滤出空字符串：

Liststrings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl"); // 获取空字符串的数量 long count = strings.stream().filter(string -> string.isEmpty()).count();

limit

limit 方法用于获取指定数量的流。 以下代码片段使用 limit 方法打印出 10 条数据：

Random random = new Random(); random.ints().limit(10).forEach(System.out::println);

sorted

sorted 方法用于对流进行排序。以下代码片段使用 sorted 方法对输出的 10 个随机数进行排序：

Random random = new Random(); random.ints().limit(10).sorted().forEach(System.out::println);

并行（parallel）程序

parallelStream 是流并行处理程序的代替方法。以下实例我们使用 parallelStream 来输出空字符串的数量：

List strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl"); // 获取空字符串的数量 long count = strings.parallelStream().filter(string -> string.isEmpty()).count();

我们可以很容易的在顺序运行和并行直接切换。

Collectors

Collectors 类实现了很多归约操作，例如将流转换成集合和聚合元素。Collectors 可用于返回列表或字符串：

Liststrings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl"); List filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList()); System.out.println("筛选列表: " + filtered); String mergedString = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.joining(", ")); System.out.println("合并字符串: " + mergedString);

统计

另外，一些产生统计结果的收集器也非常有用。它们主要用于int、double、long等基本类型上，它们可以用来产生类似如下的统计结果。

List numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5); IntSummaryStatistics stats = numbers.stream().mapToInt((x) -> x).summaryStatistics(); System.out.println("列表中最大的数 : " + stats.getMax()); System.out.println("列表中最小的数 : " + stats.getMin()); System.out.println("所有数之和 : " + stats.getSum()); System.out.println("平均数 : " + stats.getAverage());

日期时间 API

Java 8 在 java.time 包下提供了很多新的 API。以下为两个比较重要的 API：

  • Local(本地) − 简化了日期时间的处理，没有时区的问题。
  • Zoned(时区) − 通过制定的时区处理日期时间。

本地化日期时间 API

public static void main(String args[]){
    Main java8tester = new Main();
    java8tester.testLocalDateTime();
}
 
public void testLocalDateTime(){
 
    // 获取当前的日期时间
    LocalDateTime currentTime = LocalDateTime.now();
    System.out.println("当前时间: " + currentTime);
 
    LocalDate date1 = currentTime.toLocalDate();
    System.out.println("date1: " + date1);
 
    Month month = currentTime.getMonth();
    int day = currentTime.getDayOfMonth();
    int seconds = currentTime.getSecond();
 
    System.out.println("月: " + month +", 日: " + day +", 秒: " + seconds);
 
    LocalDateTime date2 = currentTime.withDayOfMonth(10).withYear(2012);
    System.out.println("date2: " + date2);
 
    // 12 december 2014
    LocalDate date3 = LocalDate.of(2014, Month.DECEMBER, 12);
    System.out.println("date3: " + date3);
 
    // 22 小时 15 分钟
    LocalTime date4 = LocalTime.of(22, 15);
    System.out.println("date4: " + date4);
 
    // 解析字符串
    LocalTime date5 = LocalTime.parse("20:15:30");
    System.out.println("date5: " + date5);
}

使用时区的日期时间API

public static void main(String args[]){
    Main java8tester = new Main();
    java8tester.testZonedDateTime();
}
 
public void testZonedDateTime(){
 
    // 获取当前时间日期
    ZonedDateTime date1 = ZonedDateTime.parse("2015-12-03T10:15:30+05:30[Asia/Shanghai]");
    System.out.println("date1: " + date1);
 
    ZoneId id = ZoneId.of("Europe/Paris");
    System.out.println("ZoneId: " + id);
 
    ZoneId currentZone = ZoneId.systemDefault();
    System.out.println("当期时区: " + currentZone);
}

测验

超链接：Java 测验 | 菜鸟教程 (runoob.com)

posted @   鱼子酱caviar  阅读(43)  评论(0)  编辑  收藏  举报
相关博文：
· java基础知识点
· java 快速入门 + 简介 （回忆篇）
· Java进阶
· Java 高级编程
· 32-JDK8 新特性
阅读排行：
· 被坑几百块钱后，我竟然真的恢复了删除的微信聊天记录！
· 没有Manus邀请码？试试免邀请码的MGX或者开源的OpenManus吧
· 【自荐】一款简洁、开源的在线白板工具 Drawnix
· 园子的第一款AI主题卫衣上架——"HELLO! HOW CAN I ASSIST YOU TODAY
· Docker 太简单，K8s 太复杂？w7panel 让容器管理更轻松！
点击右上角即可分享
微信分享提示