太尉司马懿的博客

Stream：数据的加工处理操作。 MapReduce：Map：处理数据，Reduce：分析数据。import java.util.ArrayList;import java.util.Collections;import java.util.List;import java.util.function.Predicate;import java.util.stream.Collec

sleep 是 Thread 类的方法，可以设置休眠时间，时间一到自动唤醒。 wait 是 Object 类的方法，需要等待 notify 唤醒。class Info{ private String title; private String content; private boolean flag = true; // flag == true 可以生

同步就是一个线程对象等待另一个线程对象执行完毕。 同步与异步相比较，异步操作的执行速度高，同步操作时数据的安全性较高，属于安全的线程。大部分情况下使用异步。 多个线程访问同一资源时，一定要处理好同步，可以采用同步代码块或者同步方法来实现。 过多地使用同步可能会造成死锁，死锁是程序开发中由于逻辑错误而产生的问题。并不是简单地就出现的。class MyThread imp

每当用 java 命令解释一个程序类时，操作系统就会启动一个进程，而 main 只是这新进程上的一个子线程。 JVM 启动的时候会执行 main 线程和 gc 线程。 线程的命名与取得：取得的是执行当前本方法的线程名。class MyThread implements Runnable{ @Override public void run() {

一个进程可以同时创建多个线程。 线程是比进程更快的处理单位，而且所占的资源也少，多线程的应用性能较高。 使用 start 方法不仅是为了启动多线程的执行代码，还要根据不同的操作系统进行资源的分配。class MyThread extends Thread{ private String title; public MyThread(String title){

对象序列化就是将保存在内存中的对象数据转换为二进制数据流进行传输的操作。 不是所有的类都需要被序列化，只有需要传输的对象所在的类才需要被序列化。import java.io.*;class Book implements Serializable{ // 该类可以实现对象序列化 private transient String title; // 此属性不可以被序列化 p

键盘输入import java.util.Scanner;public class Main { public static void main(String[] args) throws Exception{ boolean flag = true; while (flag){ Scanner scanner = new Scanne

键盘输入import java.io.BufferedReader;import java.io.InputStreamReader;public class Main { public static void main(String[] args) throws Exception{ BufferedReader bufferedReader = new Buffere

PrintStream：打印字节流，解决输出数据时的功能不足。 装饰设计模式：讲一个功能不足的操作类，通过某些类的包装，形成更好用的类。import java.io.*;public class Main { public static void main(String[] args) throws Exception { File fileA = new Fil

输出import java.io.OutputStream;import java.util.function.Consumer;public class Main { public static void main(String[] args) throws Exception{ OutputStream outputStream = System.out;

OutputStreamimport java.io.File;import java.io.FileOutputStream;import java.io.OutputStream;public class Main { public static void main(String[] args) throws Exception { File file = new F

在进行 java.io 操作时，会出现延迟情况，是因为 java 程序是通过 JVM 间接的调用操作系统的文件处理函数进行的文件操作，所以会出现延迟。创建文件import java.io.File;public class Main { public static void main(String[] args) throws Exception { File file =

package com.company;interface A{ public abstract void funA();}interface B{ public abstract void funB();}interface C extends A,B{ public abstract void funC();}class D implements C{

接口定义增强 接口里面使用 defaul 和 static 定义方法的意义在于：避免子类重复实现同样的代码。 接口的实现还应以抽象方法为主。interface IMessage{ public abstract void print(); default void fun(){ System.out.println("default"); }

package com.company;public class Main { public static void main(String[] args) { //构造方法不入池 String strA = new java.lang.String("helloword!"); String strB = "helloword!";

Set 子接口只是简单地继承了 Collection 接口，所以并没有 get 方法。 Set 集合中没有重复元素，这一点是 Set 接口的特征。 HashSet 子类保存的内容是无序的，TreeSet 子类保存的内容自动排序。 在 java 开发中，首先选择的是 List 子接口， Set 子接口绝对不是首选，就算是要使用 Set 子类，也首选使用 HashSet 子

Collection 是集合操作的接口，Collections 是集合操作的工具类，可以进行 List，Set，Map 集合的操作。import java.util.ArrayList;import java.util.Collections;import java.util.List;class Book{ private String title; private int

Properties 是 Hsahtable 的子类，主要是进行属性的操作（属性的最大特点是利用字符串设置 key 和 value）。 在使用 Properties 类的时候，不需要设置泛型类型，因为它一开始出现就只能保存 String。 资源文件的特点是：key = value 资源文件中的数据一定都是字符串。import java.io.File;import

栈是一种先进后出的数据结构，Stack 是 Vector 的子类，但 Stack 并不使用 Vector 的方法。 在进行栈操作的过程中，如果已经栈已经没有数据了，那么无法继续出栈。import java.util.*;class Book{ private String title; private int price; public Book(String t

Collection 接口每次只能保存一个对象，Map 接口每次保存一对对象。 使用 Collection 接口的主要目的是信息的输出，使用 Map 接口的主要目的是信息的查找。 使用 HashMap 定义的 Map 集合是无序存放的。 如果出现了重复的 Key 会进行覆盖，使用新的内容代替旧的内容。 Map 接口一般采用 HashMap 子类实现。

集合输出有四种方式：Iterator，ListIterator，Enumeration，foreach 集合输出绝大部分情况下都会使用 Iterator，Iterator 接口的实例化依靠 Collection 接口的 iterator 方法。Iteratorimport java.util.*;class Book{ private String title; priv

SimpleDateFormat 类实现 String 与 Date 之间的转换。 如果是要实现日期的计算，Calendar 类比 Date 类更合适。import java.text.SimpleDateFormat;import java.util.Calendar;import java.util.Date;public class Main { public sta

Math 类 如果进行负数四舍五入时，小数位大于 0.5 才进位，小于或者等于 0.5 不进位。public class Main { public static void main(String[] args) { System.out.println(Math.round(2.5)); System.out.println(Math.round(-2

标识接口：没有任何方法的定义，只是一个空接口的声明，标识一种操作能力。class Book implements Cloneable{ private String title; private int price; public Book(String title, int price){ this.title = title; this.

System 类中的 gc 方法直接调用了 Runtime 类中的 gc 方法。 final：定义不能被继承的类，不能被覆写的方法，常量。 finally：异常的统一出口。 finalize ：Object 类中的方法，对象回收前的收尾方法，即使出现了异常，也不会中断程序的执行。class Member{ public Member(){ System

类集就是 java 数据结构实现，类集就是动态对象数组。 Collection 是整个类集之中单值保存的最大父接口，每一次向集合中保存一个对象。 因为代码的规范化产生，所以从 PetShop 开始，就不再使用模糊不清的 Collection 接口，而都使用 List 子接口或者 Set 子接口。 java 中数据的保存数据就是数据的添加数据。 List 集合中

每一个 JVM 进程都会存在一个 Runtime 类对象，类的功能是取得一些与运行时有关的环境属性，或者创建新的进程等操作。 Runtime 类属于单例设计模式，构造方法被私有化了，为了保证整个进程中只有一个 Runtime 类对象。 Runtime 类是所有与本地运行有关的所有相关属性的集合。 GC（Garbage Collector）：垃圾收集器，释放无用的内存空间

String 类的内容一旦声明则不可改变，而StringBuffer 类和 StringBuilder 声明的内容可以改变。String 类相较于后两者执行效率更高。 StringBuffer 类中提供的方法都是同步方法，属于安全的线程操作，而 StringBuilder 中的方法是异步方法，属于非安全线程操作。public class Main { public static

Annotation Annotation：是 JDK1.5 的最大特色，利用注解的形式来实现程序的不同功能。准确的覆写：@Overrideclass Book{ @Override public String toString() { return "this is a book"; }}public class Main { public

枚举 枚举是高级的多例设计模式。 枚举对象必须放在首行，随后才可以定义属性，构造，方法。枚举中定义的构造方法不能使用 public ，因为构造方法必须私有化。 enum 是一个关键字，Enum 是一个抽象类。 使用 enum 定义的枚举就相当于一个继承 Enum 的类。 enum Color{ RED,BLUE,GREEN;}public class

import java.lang.reflect.Method;class Book{ private String title; private int price; public void setTitle(String title) { this.title = title; } public void setPrice(int pric

利用反射实现了程序解耦合的目的，同时程序的可扩展性也非常强。无参构造interface Fruit{ void eat();}class Apple implements Fruit{ public void eat(){ System.out.println("eat apple"); }}class Orange implements Fruit

package com.company;class Sex{ private String title; private static final Sex MALE = new Sex("male"); private static final Sex FEMALE = new Sex("female"); private Sex(String title){

package com.company;class Book { private String name; private int price; public Book(String name, int price) { this.name = name; this.price = price; } public String t

package com.company;//定义职员类class Emp{ private int empno; private String ename; private String job; private double sal; //定义部门信息 private Dept dept; public void setDept(Dept

拆分import java.util.Arrays;import java.util.regex.Pattern;public class Main { public static void main(String[] args) { String str = "hudr34bjd393493n2432bbj34424j343"; String regex

import java.util.Arrays;public class Main { public static void main(String[] args) { int data [] = new int[]{1,2,3,4,5,6,7,8,9,10}; int dataA [] = new int[]{1,2,3,4,5,6,7,8,9,10};

任何情况下，只要是一组对象要排序，对象所在的类一定要实现 Comparable 接口，并且要覆写 CompareTo 方法。import java.util.Arrays;class Book implements Comparable <Book>{ private String title; private int price; public Book(String t

树在本质上也属于对象数组，但是与链表不同，树的最大特征在于可以对数据进行排序。import java.util.Arrays;class Book implements Comparable <Book>{ private String title; private int price; public Book(String title, int price){

Comparator 类是专门定义一个指定类的比较规则，属于挽救的比较操作。 绝大部分情况下采用 Comparable 接口来实现对象数组的排序，不使用 Comparator 接口。import java.util.Arrays;import java.util.Comparator;class Book { private String title; private