Java-CheatSheet

Java CheatSheet | Java 语法速览与实践清单
当我们谈起 Java 的时候，往往是将其作为一门编程语言来讨论；然而编程语言的特性只是 Java 架构的某部分，保障其平台独立性的一系列底层架构也是 Java 不可分割的组成。宏观来看，我们认为 Java 主要包含以下四个部分：Java 编程语言、Java 类文件格式、Java API 以及 JVM。当我们在进行 Java 开发时，我们使用 Java 编程语言来编写代码，然后将其编译为 Java 类文件，最终在 JVM 中执行这些类文件；目前我们也可以使用 Gradle、Kotlin 等其他优秀的语言来编写 Java 应用程序。而 JVM 与 Java 平台的核心库就构成了我们所熟知的 Java Runtime Environment(JRE)：
在这里，我们首先对于 Java 的常用语法有所了解，可以参考当前目录下的 java-snippets。
Syntax | 语法基础
条件选择
循环
do{
    System.out.println("Countis:"+count);
    count++;
}while(count<11);
数据结构
如果需要判断某个对象的类型，可以通过如下方式：
a.getClass().getName()
boolean b = a instanceof String
数值类型
创建与转换
try {
    int result = Integer.parseInt(str);
} catch (NumberFormatException e) {
    System.out.println("notvalid");
}
String | 字符串
// 字符串比较
booleanresult=str1.equals(str2);
booleanresult=str1.equalsIgnoreCase(str2);
模板字符串
for(inti=0;i<str1.length();i++){
    charaChar=str1.charAt(i);
}
字符串操作
// 搜索与检索
intresult=str1.indexOf(str2);
intresult=str1.indexOf(str2,5);
Stringindex=str1.substring(14);
​
// 大小写转化
StringstrUpper=str1.toUpperCase();
StringstrLower=str1.toLowerCase();
​
// 首尾空格移除
Stringstr1="asdfsdf";
str1.trim();//asdfsdf
// 移除全部空格
str1.replace("","");
​
// 字符串反转
Stringstr1="whateverstringsomething";
StringBufferstr1buff=newStringBuffer(str1);
Stringstr1rev=str1buff.reverse().toString();
​
// 字符串转化为数组
Stringstr="tim,kerry,timmy,camden";
String[]results=str.split(",");
Regex | 正则表达式
Stringpattern="\\sa(\\w)*t(\\w)*";//contains"at"
PatternregPat=Pattern.compile(pattern);
// 多行模式
PatternregPat=Pattern.compile(pattern,Pattern.MULTILINE);
Stringtext="wordssomethingatatteafdgdatdsfhey";
Matchermatcher=regPat.matcher(text);
while(matcher.find()){
Stringmatched=matcher.group();
System.out.println(matched);
}
时间与日期类型
DatetodaysDate=newDate();//todaysdate
SimpleDateFormatformatter=newSimpleDateFormat("EEE,ddMMMyyyyHH:mm:ss");//dateformat
StringformattedDate=formatter.format(todaysDate);
System.out.println(formattedDate);
Java 8 为我们提供了 LocalDate 等类型：
longstartTime=System.currentTimeMillis();
//timesfliesby..
longfinishTime=System.currentTimeMillis();
longtimeElapsed=startTime-finishTime;
System.out.println(timeElapsed);
Collection | 集合类型
数组
构建与检索
// 数组复制
int[]myArray=newint[10];
​
int[]tmp=newint[myArray.length+10];
System.arraycopy(myArray,0,tmp,0,myArray.length);
myArray=tmp;
​
// 将 List 转化为数组
String[] stockArr = new String[stockList.size()];
stockArr = stockList.toArray(stockArr);
// HashMap 转化为数组
Object[] objects = hashmap.entrySet().toArray();
​
// 将 Stream 转化为数组
Stream<String> stringStream = Stream.of("a", "b", "c");
​
String[] stringArray = stringStream.toArray(size -> new String[size]);
String[] stringArray = stringStream.toArray(String[]::new);
​
Arrays.stream(stringArray).forEach(System.out::println);
排序
int[]nums={1,4,7,324,0,-4};
Arrays.sort(nums);
List
创建增删
检索排序
List<String>unsortList = newArrayList<String>();
Collections.sort(unsortList);
​
// 二分搜索
int[]nums = new int[]{7,5,1,3,6,8,9,2};
Arrays.sort(nums);
int index = Arrays.binarySearch(nums,6);
System.out.println("6 isatindex:" + index);
Map
HashMap map = new HashMap();
map.put(key1,obj1);
​
map.containsValue(obj);
// 遍历集合
for(Iteratorit=map.entrySet().iterator();it.hasNext();){
    Map.Entryentry=(Map.Entry)it.next();
    Objectkey=entry.getKey();
    Objectvalue=entry.getValue();
}
比较 Double:
Doublea=4.5;
    Doubleb=4.5;
​
    booleanresult=a.equals(b);
​
    if(result)System.out.println("equal");
rounding:
doubledoubleVal=43.234234200000000234040324;
    floatfloatVal=2.98f;
​
    longlongResult=Math.round(doubleVal);
    intintResult=Math.round(floatVal);
​
    System.out.println(longResult+"and"+intResult);//43and3
格式化数字:
doublevalue=2343.8798;
    NumberFormatnumberFormatter;
    StringformattedValue;
    numberFormatter=NumberFormat.getNumberInstance();
    formattedValue=numberFormatter.format(value);
    System.out.format("%s%n",formattedValue);//2.343,88
格式化货币:
doublecurrency=234546457.99;
    NumberFormatcurrencyFormatter;
    StringformattedCurrency;
​
    currencyFormatter=NumberFormat.getCurrencyInstance();
​
    formattedCurrency=currencyFormatter.format(currency);
​
    System.out.format("%s%n",formattedCurrency);//$234.546.457,99
二进制、八进制、十六进制转换:
intval=25;
StringbinaryStr=Integer.toBinaryString(val);
StringoctalStr=Integer.toOctalString(val);
StringhexStr=Integer.toHexString(val);
随机数生成:
doublern=Math.random();
    intrint=(int)(Math.random()*10);//randomintbetween0-10
​
    System.out.println(rn);
    System.out.println(rint);
计算三角函数:
doublecos=Math.cos(45);
    doublesin=Math.sin(45);
    doubletan=Math.tan(45);
formatterformatcalls:
​​​​
读取二进制数据:
InputStreamis=newFileInputStream(fileName);
intoffset=0;
intbytesRead=is.read(bytes,ofset,bytes.length-offset);
文件随机访问:
Filefile=newFile(something.bin);
RandomAccessFileraf=newRandomAccessFile(file,"rw");
raf.seek(file.length());
读取 Jar/zip/rar 文件:
ZipFilefile=newZipFile(filename);
Enumerationentries=file.entries();
while(entries.hasMoreElements()){
​
    ZipEntryentry=(ZipEntry)entries.nextElement();
    if(entry.isDirectory()){
        //dosomething
    }
    else{
        //dosomething
    }
}
file.close();
文件与目录
创建文件:
Filef=newFile("textFile.txt");
booleanresult=f.createNewFile();
文件重命名:
Filef=newFile("textFile.txt");
Filenewf=newFile("newTextFile.txt");
booleanresult=f.renameto(newf);
删除文件:
Filef=newFile("somefile.txt");
f.delete();
改变文件属性:
Filef=newFile("somefile.txt");
f.setReadOnly();//makingthefilereadonly
f.setLastModified(desiredtime);
获取文件大小:
Filef=newFile("somefile.txt");
longlength=file.length();
判断文件是否存在:
Filef=newFile("somefile.txt");
booleanstatus=f.exists();
移动文件:
Filef=newFile("somefile.txt");
Filedir=newFile("directoryName");
booleansuccess=f.renameTo(newFile(dir,file.getName()));
获取绝对路径:
Filef=newFile("somefile.txt");
FileabsPath=f.getAbsoluteFile();
判断是文件还是目录:
Filef=newFile("somefile.txt");
booleanisDirectory=f.isDirectory();
System.out.println(isDirectory);//false
:
​
:
// 列举目录下文件
Filedirectory=newFile("users/ege");
String[]result=directory.list();
​
// 创建目录
booleanresult=newFile("users/ege").mkdir();
网络客户端
服务器连接:
StringserverName="www.egek.us";
Socketsocket=newSocket(serverName,80);
System.out.println(socket);
网络异常处理:
try{
        Socketsock=newSocket(server_name,tcp_port);
        System.out.println("Connectedto"+server_name);
    sock.close();
​
}catch(UnknownHostExceptione){
    System.err.println(server_name+"Unknownhost");
    return;
}catch(NoRouteToHostExceptione){
    System.err.println(server_name+"Unreachable");
    return;
}catch(ConnectExceptione){
    System.err.println(server_name+"connectrefused");
    return;
}catch(java.io.IOExceptione){
    System.err.println(server_name+''+e.getMessage());
    return;
}
包与文档
创建包:
packagecom.ege.example;
使用 JavaDoc 注释某个类:
javadoc-d\home\html
-sourcepath\home\src
-subpackagesjava.net
类与对象
实例化
单例模式
public class Singleton {
　　private static volatile Singleton instance = null;
​
　　public static Singleton getInstance() {
　　　　if (instance == null) {
　　　　　　　　synchronized (Singleton.class) {
　　　　　　　　　　　　if (instance == null) {
　　　　　　　　　　　　　　　　instance ＝ new Singleton();
　　　　　　　　　　　　}
　　　　　　　　}
　　　　}
　　　　return instance;
　　}
}
Interface
Functional Interface & Lambda
Java 原本作为纯粹的面向对象的语言，需要对 Lambda 表达式特性进行支持，其实是基于了一种特殊的函数式接口。换言之，()->{} 这样的语法本质上还是继承并且实现了一个接口。FI 的定义其实很简单：任何接口，如果只包含 唯一 一个抽象方法，那么它就是一个 FI。为了让编译器帮助我们确保一个接口满足 FI 的要求(也就是说有且仅有一个抽象方法)，Java8 提供了@FunctionalInterface 注解。以 Runnble 为例：
@FunctionalInterface
public interface Runnable {
  public abstract void run();
}
常见的内置函数式接口还有如下：
Predicate<String> predicate = (s) -> s.length() > 0;
​
Comparator<Person> comparator = (p1, p2) -> p1.firstName.compareTo(p2.firstName);
闭包一般指存在自由变量的代码块，它与对象类似，都是用来描述一段代码与其环境的关系。在 Java 中，Lambda 表达式就是闭包。Lambda 表达式本身是构造了一个继承自某个函数式接口的子类，所以可以用父类指针指向它。Java 中本质上闭包中是采用的值捕获，即不可以在闭包中使用可变对象。但是它实际上是允许捕获事实上不变量，譬如不可变的 ArrayList，只是指针指向不可变罢了。
Lambda 表达式还可以进一步简化为方法引用(Method References)，一共有四种形式的方法引用：
// 静态方法引用
List<Integer> ints = Arrays.asList(1, 2, 3);
ints.sort(Integer::compare);
​
// 某个特定对象的实例方法
words.forEach(System.out::println);
​
// 某个类的实例方法
words.stream().map(word -> word.length()); // lambda
words.stream().map(String::length); // method reference
​
// 构造函数引用
words.stream().map(word -> {
return new StringBuilder(word);
});
// constructor reference
words.stream().map(StringBuilder::new);
Stream
Java 8 API 添加了一个新的抽象称为流 Stream，可以让你以一种声明的方式处理数据；Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。这种风格将要处理的元素集合看作一种流，流在管道中传输，并且可以在管道的节点上进行处理，比如筛选，排序，聚合等。
Stream（流）是一个来自数据源的元素队列并支持聚合操作，元素是特定类型的对象，形成一个队列；Java 中的 Stream 并不会存储元素，而是按需计算。元素流在管道中经过中间操作(intermediate operation)的处理，最后由最终操作(terminal operation)得到前面处理的结果。
+--------------------+     +------+   +------+   +---+   +-------+
| stream of elements +-----> |filter+-> |sorted+-> |map+-> |collect|
+--------------------+     +------+   +------+   +---+   +-------+
最简流程的描述如下：
List<Integer> transactionsIds =
widgets.stream()
     .filter(b -> b.getColor() == RED)
     .sorted((x,y) -> x.getWeight() - y.getWeight())
     .mapToInt(Widget::getWeight)
     .sum();
和以前的 Collection 操作不同，Stream 操作还有两个基础的特征：
Pipelining: 中间操作都会返回流对象本身。这样多个操作可以串联成一个管道，如同流式风格（fluent style）。这样做可以对操作进行优化，比如延迟执行(laziness)和短路( short-circuiting)。
内部迭代：以前对集合遍历都是通过 Iterator 或者 For-Each 的方式, 显式的在集合外部进行迭代，这叫做外部迭代。Stream 提供了内部迭代的方式，通过访问者模式(Visitor)实现。
流构建
List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
​
// 创建串行流
List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());
​
// 创建并行流，获取空字符串的数量
int count = strings.parallelStream().filter(string -> string.isEmpty()).count();
​
// 构建空流
Stream<String> streamEmpty = Stream.empty();
​
// 构建数值流
IntStream intStream = IntStream.range(1, 3); // 1, 2
LongStream longStream = LongStream.rangeClosed(1, 3);
Random random = new Random();
DoubleStream doubleStream = random.doubles(3);
​
// 构建数组流
Stream<String> streamOfArray = Stream.of("a", "b", "c");
String[] arr = new String[]{"a", "b", "c"};
Stream<String> streamOfArrayFull = Arrays.stream(arr);
Stream<String> streamOfArrayPart = Arrays.stream(arr, 1, 3);
​
// 构建文件流
Path path = Paths.get("C:\\file.txt");
Stream<String> streamOfStrings = Files.lines(path);
Stream<String> streamWithCharset =
  Files.lines(path, Charset.forName("UTF-8"));
Transform
// map 方法用于映射每个元素到对应的结果
List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
​
// 获取对应的平方数
List<Integer> squaresList = numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList());
​
// filter 方法用于通过设置的条件过滤出元素。以下代码片段使用 filter 方法过滤出空字符串
int count = strings.stream().filter(string -> string.isEmpty()).count();
​
// limit 方法用于获取指定数量的流。以下代码片段使用 limit 方法打印出 10 条数据
Random random = new Random();
random.ints().limit(10).forEach(System.out::println);
​
// sorted 方法用于对流进行排序
Random random = new Random();
random.ints().limit(10).sorted().forEach(System.out::println);
Collectors | 归约操作
List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
​
List<String> 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);
// 提取为 Map
IntStream.range(0, alphabet.size())
     .boxed()
     .collect(toMap(alphabet::get, i -> i));
数据结构
数组
// Array 转化为  List
List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
​
// List 转化为 Array
List<String> stockList = new ArrayList<String>();
...
String[] stockArr = new String[stockList.size()];
stockArr = stockList.toArray(stockArr);
Network | 网络
Storage | 存储
文件读写
Java.io 包几乎包含了所有操作输入、输出需要的类。所有这些流类代表了输入源和输出目标；Java.io 包中的流支持很多种格式，比如：基本类型、对象、本地化字符集等等。一个流可以理解为一个数据的序列。输入流表示从一个源读取数据，输出流表示向一个目标写数据。Java 为 IO 提供了强大的而灵活的支持，使其更广泛地应用到文件传输和网络编程中。
InputStream 是所有字节输入流的祖先，而 OutputStream 是所有字节输出流的祖先；Reader 是所有读取字符串输入流的祖先，而 writer 是所有输出字符串的祖先。字节流是最基本的，所有的 InputStream 和 OutputStream 的子类都是,主要用在处理二进制数据，它是按字节来处理的，但实际中很多的数据是文本，又提出了字符流的概念，它是按虚拟机的 Encode 来处理，也就是要进行字符集的转化。这两个之间通过 InputStreamReader,OutputStreamWriter 来关联，实际上是通过 byte[]和 String 来关联。字节流在操作时本身不会用到缓冲区（内存），是文件本身直接操作的，而字符流在操作时使用了缓冲区，通过缓冲区再操作文件。
控制台读写：
BufferedReaderinStream=newBufferedReader(newInputStreamReader(System.in));
Stringinline="";
while(!(inline.equalsIgnoreCase("quit"))){
System.out.println("prompt>");
inline=inStream.readLine();
}
BufferedReaderbr=newBufferedReader(newFileReader(textFile.txt));//forreading
BufferedWriterbw=newBufferedWriter(newFileWriter(textFile.txt));//forwriting
文件系统
{Thread.currentThread().getContextClassLoader() / SomeClass.class}.
{getResource("").getFile() / getResourceAsStream()}
TBD
​https://github.com/in28minutes/java-cheat-sheet​
​
Java-StyleGuide-CheatSheet
Gradle-CheatSheet
Last updated 3 months ago