public class Welcome {
  public static void main(String[] args) {
    String greeting = "Welcome to Core Java!";
    System.out.println(greeting);
    for(int i=0; i<greeting.length(); i++) {
      System.out.println("=");
    }
    System.out.println();
  }
}

javac Welcome.java
java Welcome

public class FirstSample {
  public static void main(String[] args) {
    System.out.println("We will not use 'Hello World'");
  }
}

int m = 7 ; int n = 7 ;
int a = 2 * ++m ;  // now a is 16 , m is 8
int b = 2 * n++ ; //  now b is 14 , n is 8

expression1&&expression2； 短路效果
condition？expression1：expression2

&("and") 按位与运算符，无短路效果  
|("or") 参加运算的两个对象，按二进制位进行“或”运算。

^("xor") 异或运算符；运算规则：0^0=0；0^1=1；1^0=1；1^1=0；应位为“异”（值不同），则该位结果为1
“异或运算”的特殊作用：
（1）使特定位翻转找一个数，对应X要翻转的各位，该数的对应位为1，其余位为零，此数与X对应位异或即可。
例：X=10101110，使X低4位翻转，用X ^ 0000 1111 = 1010 0001即可得到。
（2）与0相异或，保留原值 ，X ^ 0000 0000 = 1010 1110。

~("not") 取反运算符；按二进制位进行“取反”运算。
使一个数的最低位为零，可以表示为：a&~1。
<< 左移运算符；将一个运算对象的各二进制位全部左移若干位（左边的二进制位丢弃，右边补0）。左移1位后a = a * 2; 
 >> 操作数每右移一位，相当于该数除以2。
int fourthBit操作数每右移一位，相当于该数除以2。FromRight = ( n & ( 1 « 3 ) ) » 3 ;
>>>  无符号右移运算符； 运算符0填充高位; >> 用符号位填充高位 不存在 <<<

enum Size { SMALL , MEDIUM , LARGE , EXTRA LARCE } ;
//现在 ，可以声明这种类型的变量
Size s = Size.MEDIUM;
//Size 类型的变量只能存储这个类型声明中给定的某个枚举值 或者 null 值

 java.lang.String  
  
 char charAt (int index)     返回index所指定的代码单元(字符1：1； 除了辅助字符2个)
 String concat(String str)   将两字符串连接  
 boolean endsWith(String str)    测试字符串是否以str结尾  
 boolean equals(Object obj)  比较两对象  
 char[] getBytes     将字符串转换成字符数组返回  
 char[] getBytes(String str)     将指定的字符串转成制服数组返回  
 boolean startsWith(String str)  测试字符串是否以str开始  
 int length()    返回字符串的长度  
 String replace(char old ,char new)  将old用new替代  
 char[] toCharArray  将字符串转换成字符数组  
 String toLowerCase()    将字符串内的字符改写成小写  
 String toUpperCase()    将字符串内的字符改写成大写  
 String valueOf(Boolean b)   将布尔方法b的内容用字符串表示  
 String valueOf(char ch)     将字符ch的内容用字符串表示  
 String valueOf(int index)   将数字index的内容用字符串表示  
 String valueOf(long l)  将长整数字l的内容用字符串表示  
 String substring(int1,int2)     取出字符串内第int1位置到int2的字符串  

1.构造方法
//直接初始化
String str = "abc";
//使用带参构造方法初始化
char[] char = {'a','b','c'};
String str1 = new String("abc");String str2 = new String(str);
String str3 = new String(char);
2.求字符串长度和某一位置字符
String str = new String("abcdef");
int strlength = str.length();//strlength = 7
char ch = str.charAt(4);//ch = e
for (int i = 0; i < greeting.length(); i++) {
            System.out.println(greeting.charAt(i));
        }

        char[] cArray=greeting.toCharArray();
        for(char cc:cArray){
        }
3.提取子串
用String类的substring方法可以提取字符串中的子串，该方法有两种常用参数:
1)public String substring(int beginIndex)//该方法从beginIndex位置起，从当前字符串中取出剩余的字符作为一个新的字符串返回。
2)public String substring(int beginIndex, int endIndex)//该方法从beginIndex位置起，从当前字符串中取出到endIndex-1位置的字符作为一个新的字符串返回。作者：HCherisher
String str1 = new String("abcdef");
String str2 = str1.substring(2);//str2 = "cdef"
String str3 = str1.substring(2,5);//str3 = "cde"
4.字符串比较
1)public int compareTo(String anotherString)//该方法是对字符串内容按字典顺序进行大小比较，通过返回的整数值指明当前字符串与参数字符串的大小关系。若当前对象比参数大则返回正整数，反之返回负整数，相等返回0。
2)public int compareToIgnoreCase(String anotherString)//与compareTo方法相似，但忽略大小写。
3)public boolean equals(Object anotherObject)//比较当前字符串和参数字符串，在两个字符串相等的时候返回true，否则返回false。
4)public boolean equalsIgnoreCase(String anotherString)//与equals方法相似，但忽略大小写。作者：HCherisher
String str1 = new String("abc");
String str2 = new String("ABC");
int a = str1.compareTo(str2);//a>0
int b = str1.compareToIgnoreCase(str2);//b=0
boolean c = str1.equals(str2);//c=false
boolean d = str1.equalsIgnoreCase(str2);//d=true
5.字符串链接
public String concat(String str)//将参数中的字符串str连接到当前字符串的后面，效果等价于"+"
String str = "aa".concat("bb").concat("cc");
//相当于String str = "aa"+"bb"+"cc";
6.字符串中单个字符查找
1)public int indexOf(int ch/String str)//用于查找当前字符串中字符或子串，返回字符或子串在当前字符串中从左边起首次出现的位置，若没有出现则返回-1。
2)public int indexOf(int ch/String str, int fromIndex)//改方法与第一种类似，区别在于该方法从fromIndex位置向后查找。
3)public int lastIndexOf(int ch/String str)//该方法与第一种类似，区别在于该方法从字符串的末尾位置向前查找。
4)public int lastIndexOf(int ch/String str, int fromIndex)//该方法与第二种方法类似，区别于该方法从fromIndex位置向前查找作者：HCherisher
String str = "I really miss you !";
int a = str.indexOf('a');//a = 4
int b = str.indexOf("really");//b = 2
int c = str.indexOf("gg",2);//c = -1
int d = str.lastIndexOf('s');//d = 6
int e = str.lastIndexOf('s',7);//e = 7
7.大小写转换
1)public String toLowerCase()//返回将当前字符串中所有字符转换成小写后的新串
2)public String toUpperCase()//返回将当前字符串中所有字符转换成大写后的新串
8.字符串中字符的替换
1)public String replace(char oldChar, char newChar)//用字符newChar替换当前字符串中所有的oldChar字符，并返回一个新的字符串。
2)public String replaceFirst(String regex, String replacement)//该方法用字符replacement的内容替换当前字符串中遇到的第一个和字符串regex相匹配的子串，应将新的字符串返回。
3)public String replaceAll(String regex, String replacement)//该方法用字符replacement的内容替换当前字符串中遇到的所有和字符串regex相匹配的子串，应将新的字符串返回。
String str = "asdzxcasd";
String str1 = str.replace('a','g');//str1 = "gsdzxcgsd"
String str2 = str.replace("asd","fgh");//str2 = "fghzxcfgh"
String str3 = str.replaceFirst("asd","fgh");//str3 = "fghzxcasd"
String str4 = str.replaceAll("asd","fgh");//str4 = "fghzxcfgh"
9.其他方法
1)String trim()//截去字符串两端的空格，但对于中间的空格不处理。
String str = " a bc ";
String str1 = str.trim();
int a = str.length();//a = 6
int b = str1.length();//b = 4
2)boolean statWith(String prefix)或boolean endWith(String suffix)//用来比较当前字符串的起始字符或子字符串prefix和终止字符或子字符串suffix是否和当前字符串相同，重载方法中同时还可以指定比较的开始位置offset。作者：HCherisher
String str = "abcdef";
boolean a = str.statWith("ab");//a = true
boolean b = str.endWith("ef");//b = true
3)contains(String str)//判断参数s是否被包含在字符串中，并返回一个布尔类型的值。
String str = "abcdef";
str.contains("ab");//true
str.contains("gh");//false
4)String[] split(String str)//将str作为分隔符进行字符串分解，分解后的字字符串在字符串数组中返回。
String str = "abc def ghi";
String[] str1 = str.split(" ");//str1[0] = "abc";str1[1] = "def";str1[2] = "ghi";
10.类型转换
字符串转基本类型
java.lang包中有Byte、Short、Integer、Float、Double类的调用方法：
public static byte parseByte(String s)
public static short parseShort(String s)
public static short parseInt(String s)
public static long parseLong(String s)
public static float parseFloat(String s)
public static double parseDouble(String s)
int n = Integer.parseInt("12");
float f = Float.parseFloat("12.34");
double d = Double.parseDouble("1.124");
//将char '8' 转换为int 8
String str = String.valueOf('8');
String str = String.valueOf(8.1);
int num = Integer.parseInt(str);
进制转换
使用Long类中的方法得到整数之间的各种进制转换的方法：
Long.toBinaryString(long l)//二进制
Long.toOctalString(long l)//十进制
Long.toHexString(long l)//十六进制
Long.toString(long l, int p)//p作为任意进制

String a = "Hello";    
String b = new String("Hello");    
String c = new String("Hello");    
System.out.println( a == b );//false
System.out.println( “**********” );    
b.intern();   
c = c.intern(); //把常量池中"Hello"的引用赋给c    
System.out.println( a == b);//false虽然执行了b.intern()但没有赋值给b
System.out.println( a == b.intern() );//true  
System.out.println( a == c ); //true

StringBuilder builder = new String StringBuilder();
// 每次添加一个部分内容，就需要调用append方法。
builder.append(ch); // 添加一个字符
builder.append(str); //appends a string
// 需要构建字符串时，就调用toString方法，得到一个String对象。
String completeString = builder.toString();

- StringBuilder()
构造一个空的字符串构建器 。
- int length ( ) 
返回构建器或缓冲器中的代码单元数量 。 
- StringBui1der append(String str)
追加一个字符串并返回 this 。
- StringBui1der append ( char c )
追加一个代码单元并返回 this 。 
- StringBui1der appendCodePoint(int cp) 
追加一个代码点 并将其转换为一个或两个代码单元并返回 this 
- void setCharAt (int i , char c) 
将第i个代码单元设置为 c 。 
- StringBui1der insert(int offset , String str) 
在 offset 位置插入一个字符串并返回 this 。 
- StringBuilder insert ( int offset , Char c ) 
  在 offset 位置插入一个代码单元并返回 this 。 
- StringBui1der delete (int startindex , int endlndex) 
删除偏移量从 startindex 到 endlndex - 1 的代码单元并返回 this 。 
- String toString () 
返回一个与构建器或缓冲器内容相同的字符串

// 首先 构造一个Scanner 对象，并且与 "标准输入流" System.in关联
Scanner in = new Scanner(System.in);
//现在 就可以使用 Scanner类的各种方法实现输入操作了 例如 nextLine方法将输入一行
System.out.print("What is your name? ");
String name = in.nextLine(); // 使用 nextLine 方法是因为在输人行中有可能包含空格
// 要想读取一个单词 （ 以空白符作为分隔符) 就调用
String firstName = in.next();
// 要想读取一个整数 ，就调用nextlnt 方法
System.out.print("How old are you? ");
int age = in.nextInt();
// 要想读取下一个浮点数 调用nextDouble
// 添加库 import java.util.*;
// Scanner 类定义在 java . util 包中 当使用的类不是定义在基本 java . lang 包中时 一定要使用import 指示字将相应的包加载进来

import java.util.*;
public class InputTest {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
//        System.out.println("What's your name? ");
        String name = in.nextLine();
//        System.out.println("How old are you?");
        int age = in.nextInt();
        System.out.println("your name: "+ name + ", your age: "+age);
    }
}

// 用给定的输人流创建一个 Scanner 对象
- Scanner(InputStream in)
// 读取输入的下一行内容
- String nextLine()
// 读取输入的下一个单词 （ 以空格作为分隔符)
- String next()
// 读取下一个整型
- int nextInt()
// 读取并转换下一个表示整数或浮点数的字符序列
- double nextDouble()
// 检测输人中是否还有其他单词
- boolean hasNext ( )
- boolean hasNextInt ( )
- boolean hasNextDouble ( )

System.out.printf("%8.2f", x);
System.out.printf("Hello, %s. Next year, you will be %d", name, age);
System.out.printf("%,.2f", 10000.0/3.0);  3,333.33

String message = String.format("Hello, %s. Next Year you will be %d", name, age+1);

Scanner in = new Scanner(Paths.get("myfile.txt"),"UTF-8");

PrintWriter out = new PrintWriter("myfile.txt", "UTF-8");

- Scanner(File f) // 构造一个从给定文件读取数据的Scanner
- Scanner(String data) // 构造一个从给定字符串读取的数据的Scanner
- PrintWriter(String fileName) // 构造一个将数据写入文件的PrintWriter。文件名由参数指定
- static Path get(String pathname) // 根据给定的路径名构造一个Path

if (condition) {
	statement1;
	statement2;
}

while(condition) {
	statement1;
	statement2;
}

for(int i = 0; i <= 10; i++) {

}

read_data:
        while (n == 1) {
            for (int i = 0; i<n; i++) {
                for (int j= 0; j<2; j++) {
                    break read_data;
                }
            }
        }
标签必须放在希望跳出的最外层循环之前,并且必须紧跟一个冒号

BigInteger a = BigInteger.valueOf(100);
BigInteger c = a.add(b);
BigInteger d = c.multiply(b.add(BigInteger.valueOf(2)));

BigInteger add(BigInteger other);
BigInteger divide(BigInteger other);
BigInteger mod(BigInteger other);
int CompareTo(BigInteger other);
static BigInteger valueOf(long x);

int[] a; //该语句只声明了变量a，没有讲a初始化一个真正的数组，应使用new
int[] a = new int[100]; // 数组长度不要求是常量 newint [ n ] 会创建一个长度为 n 的数组

int[] a = new int[100];
for(int i =0; i<100; i++) {
  a[i] = i;
}// 
String[] names = new String[10];
for(int i =0; i<10; i++) names[i] = "";
for(int i =0; i<names.length; i++) {
  System.out.println(a[i]);
}

for each循环使用 //这个循环应该读作 “ 循环 a 中的每一个元素 ” （ for each element in a )
for (variable: collection)
	statement
for(int element : a)
	System,out.println(element); 
				int[] a = new int[10];
        for (int i = 0; i< 10; i++) {
            a[i] = i;
        }
        for (int x : a) {
            System.out.print(x+" ");
        }
        System.out.println(Arrays.toString(a));

int[] smallPrimes = {1, 2,3, 4,5,6}; 
还可以匿名初始化数组:
new int[] {1,2, 3,54,6}
smallPrimes = new int[] {1, 3, 5};
这是下列语句的简写形式：
int[] anoymous = {1,2,4};

int[] luckyNumbers = new int{1, 3,34};
int[] badLucky = luckyNumbers;

badLucky[2] = 21;
//如果希望将一个数组的所有值拷贝到一个新的数组中去,使用Arrays.copyOf
int[] copiedLuckyNumbers = Arrays.copyOf(luckyNumbers,luckyNumbers.length)
 // 第 2 个参数是新数组的长度,这个方法通常用来增加数组的大小 ：数组元素是数值型,0;boolean->false

double[][] balances;
balances = new double[NYEARS][NRATES];

int[][] magicSquare = {
 {1, 2, 4, 5},
 {1, 2, 4, 5},
 {1, 2, 4, 5},
 {1, 2, 4, 5},
};

for (double[] row : a) {
	for (doule index : row) {
		do
	}
}
//要想快速地打印一个二维数组的数据元素列表
Arrays.deepToString(a);