F1 或 Ctrl+Shift+P : 打开命令面板。在打开的输入框内，可以输入任何命令，例如：
按一下 Backspace 会进入到 Ctrl+P 模式
在 Ctrl+P 下输入 > 可以进入 Ctrl+Shift+P 模式
在 Ctrl+P 窗口下还可以:
-直接输入文件名，跳转到文件

? 列出当前可执行的动作
! 显示 Errors或 Warnings，也可以 Ctrl+Shift+M
: 跳转到行数，也可以 Ctrl+G 直接进入
@ 跳转到 symbol（搜索变量或者函数），也可以 Ctrl+Shift+O 直接进入
@ 根据分类跳转 symbol，查找属性或函数，也可以 Ctrl+Shift+O 后输入:进入

打开一个新窗口： Ctrl+Shift+N
关闭窗口： Ctrl+Shift+W
同时打开多个编辑器（查看多个文件）
新建文件 Ctrl+N
文件之间切换 Ctrl+Tab
切出一个新的编辑器（最多 3 个） Ctrl+\，也可以按住 Ctrl 鼠标点击 Explorer 里的文件名
左中右 3 个编辑器的快捷键 Ctrl+1 Ctrl+2 Ctrl+3
3 个编辑器之间循环切换 Ctrl+
编辑器换位置， Ctrl+k然后按 Left或 Right

代码行缩进: Ctrl+[ 、 Ctrl+]
Ctrl+C 、 Ctrl+V 复制或剪切当前行/当前选中内容
代码格式化： Shift+Alt+F，或 Ctrl+Shift+P 后输入 format code
上下移动一行： Alt+Up 或 Alt+Down
向上向下复制一行： Shift+Alt+Up 或 Shift+Alt+Down
在当前行下边插入一行: Ctrl+Enter
在当前行上方插入一行 Ctrl+Shift+Enter

移动到行首： Home
移动到行尾： End
移动到文件结尾： Ctrl+End
移动到文件开头： Ctrl+Home
移动到定义处： F12
定义处缩略图：只看一眼而不跳转过去 Alt+F12
移动到后半个括号： Ctrl+Shift+]
选择从光标到行尾： Shift+End
选择从行首到光标处： Shift+Home
删除光标右侧的所有字： Ctrl+Delete
扩展/缩小选取范围： Shift+Alt+Left 和 Shift+Alt+Right
多行编辑(列编辑)：Alt+Shift+鼠标左键， Ctrl+Alt+Down/Up
同时选中所有匹配： Ctrl+Shift+L
Ctrl+D 下一个匹配的也被选中 (在 sublime 中是删除当前行，后面自定义快键键中，设置与 Ctrl+Shift+K 互换了)
回退上一个光标操作： Ctrl+U
选中所有匹配词批量编辑：鼠标高亮选中需要查找的词，按下 Ctrl + Shift + L键，即可快速选中当前文件中所有匹配的词，并在每一个词后面有一个编辑光标，可批量同步编辑

找到所有的引用： Shift+F12
同时修改本文件中所有匹配的： Ctrl+F12
重命名：比如要修改一个方法名，可以选中后按 F2，输入新名字，回车，则所有该方法的引用也都同步更新了
跳转到下一个 Error 或 Warning：当有多个错误时可以按 F8 逐个跳转
查看 diff： 在 explorer 里选择文件右键 Set file tocompare，然后需要对比的文件上右键选择 Compare with file_name_you_chose
查找替换
查找 Ctrl+F
查找替换 Ctrl+H
整个文件夹中查找 Ctrl+Shift+F

全屏：F11
zoomIn/zoomOut：Ctrl +/-
侧边栏显/隐： Ctrl+B
显示资源管理器 Ctrl+Shift+E
显示搜索 Ctrl+Shift+F
显示 Git Ctrl+Shift+G
显示 Debug Ctrl+Shift+D
显示 Output Ctrl+Shift+U

自动保存：File -> AutoSave，或者 Ctrl+Shift+P，输入 auto
修改默认快捷键
打开默认键盘快捷方式设置：File -> Preferences -> Keyboard Shortcuts，或者：Alt+F -> p -> k

PostCSS Sorting
stylelint
stylefmt
ESLint
javascript standard format
beautify
Babel ES6/ES7
Debugger for Chrome
Add jsdoc comments
javascript(ES6) code snippets
vue
weex
Reactjs code snippets
React Native Tools
Npm Intellisense
Instant Markdown
Markdown Shortcuts
TextTransform
使用等宽字体：
Fira Code

List<String> list = new ArrayList<>();
        list.add("123");
        list.add("456");
        list.add("789");

        Stream<String> stream = list.stream();//通过集合创建流

        Stream<String> stream1 =  Stream.of(new String[]{"123","456","789"});//通过数组创建流

        Stream<String> stream2 =  Stream.of("123","456","789");//通过具体数据创建流

        Stream<Double> stream3 = Stream.generate(Math::random); //创建无限流，上面的都是有限流

        Stream<Integer> stream4 = Stream.iterate(0, integer -> ++integer);//创建无限序列

        Stream<String> stream5 = Stream.empty();//产生空的流

        String[] strings = new String[]{"123","456","789"};//使用Arrays创建流
        Stream stream6 = Arrays.stream(strings);

 List<String> list = new ArrayList<>();
        list.add("12345");
        list.add("123");
        list.add("6789");
        Stream filterTest = list.stream().filter(p->p.length() >= 4);//获取长度大于等于4的字符串的流
        filterTest.forEach(System.out::println);

输出结果：

12345
6789

List<String> list = new ArrayList<>();
        list.add("12345");
        list.add("123");
        list.add("6789");
        Stream mapTest = list.stream().map(String::length);
        mapTest.forEach(System.out::println);

等同于

List<String> list = new ArrayList<>();
        list.add("12345");
        list.add("123");
        list.add("6789");
        Stream mapTest = list.stream().map(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                return s.length();
            }
        });
        mapTest.forEach(System.out::println);

<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);
<R> Stream<R> map(Function<? super T, ? extends R> mapper);

List<String> list = new ArrayList<>();
        list.add("12345");
        list.add("123");
        list.add("6789");
        list.stream().limit(2).forEach(System.out::println);//limit只保留前面指定元素个数
        list.stream().skip(1).forEach(System.out::println);//skip跳过前面指定元素个数
        System.out.println("===============");
        //concat连接两个流(a,b)，它产生的流是a元素后面跟着b元素，注意：第一个流不能是无限流，比如第二个元素永远不能得到处理的机会
        Stream.concat(list.stream(),list.stream()).forEach(System.out::println);

Stream<T> distinct() //产生一个流，包含原来流中所有不同的元素

Stream<T> sorted()//排序流，要求流中元素都实现 Comparable 接口
Stream<T> sorted(Comparator<? super T> comparator)//排序流

//peek方法会产生另一个流，它的元素与原来流中相同，但是在每一次获取一个元素时
//都会调用action中的方法，这对于调试很方便
Stream<T> peek(Consumer<? super T> action)

List<String> list = new ArrayList<>();
        list.add("12345");
        list.add("123");
        list.add("6789");

        Optional<String> v =  list.stream().max(Comparator.comparingInt(String::length));
        Optional<String> v1 =  list.stream().min(Comparator.comparingInt(String::length));
        Optional<String> v2 =  list.stream().findFirst();
        Optional<String> v3 =  list.stream().findAny();
        boolean v4 =  list.stream().anyMatch(t->t.length()>3);//是否有任意个匹配
        boolean v5 = list.stream().noneMatch(t->t.length()>3);//是否没有一个匹配
        boolean v6 = list.stream().allMatch(t->t.length()>3);//是否都匹配
        System.out.println(v.get());
        System.out.println(v1.get());
        System.out.println(v2.get());
        System.out.println(v3.get());
        System.out.println(v4);
        System.out.println(v5);
        System.out.println(v6);

结果为：

12345
123
12345
12345
true
false
false

//of 方法产生具有给定值的Optional
Optional<String> value = Optional.of("123");
//产生一个空的Optional,不能使用 get 方法，否则会保错
Optional<String> value1 = Optional.empty();
//如果给定的值为null,则产生一个空的Optional,否则产生具有给定值的Optional
Optional<String> value2 = Optional.ofNullable(null);

Optional<String> value = Optional.empty();
String result = value.orElse("");//如果Optional的给定值为null,则会返回默认值 ""
String result1 = value.orElseGet(()->"");//如果Optional的给定值为null,则会调用指定方法返回值
String result2 =value.orElseThrow(IllegalStateException::new);//如果Optional的给定值为null,则会抛出错误
value.ifPresent(System.out::println);//只有Optional的值不为null时，才执行指定方法

Optional<String> value = Optional.of("12345");
//Optional的 map 和流的 map 方法差不多，它可以转换Optional的类型，例如下面从 Optional<String> 转换为 Optional<Integer>
//注意：如果上面的 value 为空的Optional，或者 value.map(v->null) ,则会返回空的Optional(即Optional.empty())
Optional<Integer> optional = value.map(String::length);
System.out.println(optional);

//和map差不多
 Optional<String> value = Optional.of("12345");
 Optional<Integer> integer = value.flatMap(s->Optional.of(s.length()));

    //流转化为数组
    String[] array = (String[]) stream.toArray();
    String[] arrays = stream.toArray(String[]::new);

    //流转化为指定的集合
    List<String> list1 = stream.collect(Collectors.toList());
    Set<String> set = stream.collect(Collectors.toSet());
    ArrayList<String> arrayList = stream.collect(Collectors.toCollection(ArrayList::new));
    //映射表
    Map<Integer,String> map = stream.collect(Collections.toMap(Person::getId,Person::getName))
    Map<Integer,Person> map = stream.collect(Collections.toMap(Person::getId,Function.identity()))
    //第三个参数用来处理键发生冲突的情况，默认是抛出异常
    Map<Integer,String> map = stream.collect(Collections.toMap(Person::getId,Person::getName,(existValue,newValue)->existValue))
    //转化为指定的 Map
    Map<Integer,String> map = stream.collect(Collections.toMap(Person::getId,Person::getName),TreeMap::new)

    //连接流中的元素，可以指定分隔符
    String result = stream.collect(Collectors.joining());
    String result1 = stream.collect(Collectors.joining(","));

    //有(Double|Long|Int)三种，下面只列举了Int，其他类似
    IntSummaryStatistics summaryStatistics = stream.collect(Collectors.summarizingInt(String::length));
    double average = summaryStatistics.getAverage();//平均值
    double maxWordLength = summaryStatistics.getMax();//最大值
    long sum = summaryStatistics.getSum();//总和
    long count = summaryStatistics.getCount();//元素个数

    //通过群组和分区来指定映射表
    List<Student> students = new ArrayList<>();
    Student student1=new Student(1,"小明");
    Student student2=new Student(2,"小军");
    Student student3=new Student(1,"小红");
    Student student4=new Student(1,"小键");
    students.add(student1);
    students.add(student2);
    students.add(student3);
    students.add(student4);
    //通过班级的名字来分组
    Map<Integer,List<Student>> cl=students.stream().collect(Collectors.groupingBy(Student::getClassName));
    //通过判断班级名是否为2来分组
    Map<Boolean,List<Student>> cl1=students.stream().collect(Collectors.partitioningBy(l->l.getClassName()==2));

    List<Teacher> teachers = new ArrayList<>();
    Teacher teacher1=new Teacher("北京","小明",26);
    Teacher teacher2=new Teacher("重庆","小军",30);
    Teacher teacher3=new Teacher("上海","小红",26);
    Teacher teacher4=new Teacher("北京","小键",34);
    teachers.add(teacher1);
    teachers.add(teacher2);
    teachers.add(teacher3);
    teachers.add(teacher4);
    //通过工作地点把教师分组后，使用 Collectors.counting() 方法计算每组的人数
    //和 Collectors.counting() 类似的对分好组的集合进行操作的方法有:
    //summingInt/Long/Double 通过传递一个 返回值为 int/long/double 的函数来对已经分好组的集合进行操作，并求其和
    //maxBy和minBy 获取分好组集合中的最大值或最小值
    Map<String,Long> c=teachers.stream().collect(Collectors.groupingBy(Teacher::getWorkplace,Collectors.counting()));
    //通过工作地点把教师分组后，通过 Collectors.mapping() 方法对已经分好组的集合使用 getAge()方法获取这个集合中各个老师的年龄
    //并放在一个新的集合中
   Map<String,Set<Integer>> c =
   teachers.stream().collect(Collectors.groupingBy(Teacher::getWorkplace,Collectors.mapping(Teacher::getAge,Collectors.toSet())));
}

//独有构造方法
//range()、rangeClosed(),IntStream和LongStream独有
IntStream t=IntStream.range(0,10);//范围 [0,10)
IntStream t1=IntStream.rangeClosed(0,10);//[0,10]

//codePonts chars 生成由字符的Unicode码或由UTF-16编码机制的码元构成的IntStream,这两个方法的区别暂时还不清楚
String s = "gkdl;iofk;slaksdk,sdki\uD835";
IntStream i1 = s.chars();
IntStream i2 = s.codePoints();

//mapToInt mapToLong mapToDouble
IntStream stream = teachers.stream().mapToInt(Teacher::getAge);

//将基本类型流转化为对象流
Stream<Integer> t=IntStream.range(0,10).boxed();

//这里的OptionalInt和Optional类似
OptionalInt o1= t.max();//最大值
OptionalInt o2=t.min();//最小值
OptionalDouble o3=t.average();//平均值
int sum = t.sum();//总和

//返回由随机数构成的基本类型
Random random = new Random();
IntStream r1 = random.ints();
DoubleStream r2 = random.doubles();
LongStream r3 = random.longs();

//创建并行流
Collection.parallelStream()//集合转为并行流

Stream.parallel()//流转为并行流

@FunctionalInterface
public interface Comparator<T> {

    int compare(T o1, T o2);

    //重新声明Object中的方法会让方法不再是抽象方法
    boolean equals(Object obj);

    default Comparator<T> reversed() {
        return Collections.reverseOrder(this);
    }

    public static <T> Comparator<T> nullsFirst(Comparator<? super T> comparator) {
        return new Comparators.NullComparator<>(true, comparator);
    }

    ....

}

//注意：由于带Comparator的sort方法参数声明为泛型，所有无法使用基本类型
Integer word[] =   new Integer[]{12,23};
Arrays.sort(word,(e1, e2)-> e1 - e2);

//上面的代码相当于下面的代码，可以看出lambda可以使代码简洁
Integer word[] =   new Integer[]{12,23};
Arrays.sort(word, new Comparator<Integer>() {
          @Override
          public int compare(Integer e1, Integer e2) {
              return e1 - e2;
          }
      });


Predicate<Boolean> isNull = Objects::isNull;
System.out.println(isNull.test(null));
//等同于
Predicate<Boolean> isNull = new Predicate<Boolean>() {
            @Override
            public boolean test(Boolean aBoolean) {
                return Objects.isNull(aBoolean);
            }
        };
    System.out.println(isNull.test(null));

public void requestMessage(String text,int delay){
       ActionListener actionListener = e -> {
           System.out.println(text);//使用变量text
           ...
       };
   }

public class Hel {  
    public static void main(String[] args){  
        String str = "你好hello";  
            int byte_len = str.getBytes().length;  
            int len = str.length();  
            System.out.println("字节长度为：" + byte_len);  
        System.out.println("字符长度为：" + len);  
        System.out.println("系统默认编码方式：" + System.getProperty("file.encoding"));  
       }  
}

public interface Closeable extends AutoCloseable {
    public void close() throws IOException;
}

public interface Readable {
    //CharBuffer可以按顺序或随机进行读写
    public int read(java.nio.CharBuffer cb) throws IOException;
}

public interface Appendable {

    Appendable append(CharSequence csq) throws IOException;

    Appendable append(CharSequence csq, int start, int end) throws IOException;

    Appendable append(char c) throws IOException;
}

File (String pathname)
File（URI uri）
File (String parent , String child)
File (File parent , String child)

public boolean exists( ) 判断文件或目录是否存在

public boolean isFile( ) 判断是文件还是目录

public boolean isDirectory( ) 判断是文件还是目录

public String getName( ) 返回文件名或目录名

public String getPath( ) 返回文件或目录的路径。

public long length( ) 获取文件的长度

public String[ ] list () 将目录中所有文件名和目录名保存在字符串数组中返回

public File[] listFiles() 返回某个目录下所有文件和目录的绝对路径，返回的是File数组

public String getAbsolutePath() 返回文件或目录的绝对路径

public boolean renameTo( File newFile ); 重命名文件

public void delete( );   删除文件

public boolean mkdir( ); 创建单个文件夹

public boolean mkdirs();可以建立多级文件夹

public boolean createNewFile(); 创建文件

File file = new File("D:\\test");
if(file.mkdir()){
    File f = new File(file,"test1.txt");
    f.createNewFile();
}

public final class FileDescriptor {
    /**
     * 在形式上是一个非负整数。
     * 实质是一个索引值，指向内核为每一个进程所维护的该进程打开文件的记录表。
     * 当程序打开一个现有文件或者创建一个新文件时内核向进程返回一个文件描述符。
     */
    private int descriptor;

    public /**/ FileDescriptor() {
        descriptor = -1;
    }

    private /**/ FileDescriptor(int descriptor) {
        this.descriptor = descriptor;
    }

    /**
     * (03)err -- 标准错误输出(屏幕)的描述符
     * @see     java.lang.System#in
     */
    public static final FileDescriptor in = dupFd(0);

    /**
     * (01)in -- 标准输入(键盘)的描述符 
     * @see     java.lang.System#out
     */
    public static final FileDescriptor out = dupFd(1);

    /**
     * (02)out -- 标准输出(屏幕)的描述符  
     * @see     java.lang.System#err
     */
    public static final FileDescriptor err = dupFd(2);

    ......
    //工具构造方法
    private static FileDescriptor dupFd(int fd) {
        try {
            return new FileDescriptor(Os.fcntlInt(new FileDescriptor(fd), F_DUPFD_CLOEXEC, 0));
        } catch (ErrnoException e) {
            throw new RuntimeException(e);
        }
    }
    ......
}

//模式有四种：r 表示只读 rw 表示读写模式  rws 表示每次更新时都对数据和元数据
//的写磁盘操作进行同步  rwd 表示每次更新时，只对数据的写磁盘操作进行同步
//注：元数据即数据的信息，比如数据的创建修改时间，数据是文件还是目录等
RandomAccessFile file = new RandomAccessFile("文件名","模式");

RandomAccessFile file1 = new RandomAccessFile(File,"mode");

long getFilePointer() 返回文件指针的位置

void seek(long pos) 将文件指针设置到距文件开头的pos字节处

long length() 返回文件按照字节来度量的长度

final void     writeBoolean(boolean val)
final void     writeByte(int val)
final void     writeBytes(String str)
final void     writeChar(int val)
final void     writeChars(String str)
final void     writeDouble(double val)
final void     writeFloat(float val)
final void     writeInt(int val)
final void     writeLong(long val)
final void     writeShort(int val)
final void     writeUTF(String str) 使用utf-8编码格式写入字符串
final void     write() 写入字节

public interface Collection<E> extends Iterable<E>

/**
 * 返回一个迭代器
 */
Iterator<T> iterator();

/**
 *Java 8的新特性，之后介绍
 */
default void forEach(Consumer<? super T> action) {
    Objects.requireNonNull(action);
    for (T t : this) {
        action.accept(t);
    }
}

/**
 * Java 8的新特性，之后介绍
 */
default Spliterator<T> spliterator() {
    return Spliterators.spliteratorUnknownSize(iterator(), 0);
}

public interface Iterator<E> {
    /**
     *判断集合中是否还存在元素
     */
    boolean hasNext();

    /**
     *返回下一个元素
     */
    E next();

    /**
     *将迭代器新返回的元素删除
     */
    default void remove() {
        throw new UnsupportedOperationException("remove");
    }

    /**
     *Java 8新特性，之后介绍
     */
    default void forEachRemaining(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }
}

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{

public Iterator<E> iterator() {
        return new Itr();
    }


private class Itr implements Iterator<E> {
    ...
}
}

boolean add(Object o)添加对象到集合
boolean remove(Object o)删除指定的对象
int size()返回当前集合中元素的数量
boolean contains(Object o)查找集合中是否有指定的对象
boolean isEmpty()判断集合是否为空
Iterator iterator()返回一个迭代器
boolean containsAll(Collection c)查找集合中是否有集合c中的元素
boolean addAll(Collection c)将集合c中所有的元素添加给该集合
void clear()删除集合中所有元素
void removeAll(Collection c)从集合中删除c集合中也有的元素
void retainAll(Collection c)从集合中删除集合c中不包含的元素

public boolean isEmpty()
public boolean contains(Object o)
public Object[] toArray()
public <T> T[] toArray(T[] a)
public boolean add(E e)
public boolean remove(Object o)
public boolean containsAll(Collection<?> c)
public boolean addAll(Collection<? extends E> c)
public boolean removeAll(Collection<?> c)
public boolean retainAll(Collection<?> c)
public String toString()

add(E e);
remove();
element();
clear();
addAll(Collection<? extends E> c);