java基础复习-Java介绍

//单行注释

/**
文档注释
*/

/*多行注释*/

Object object = getObject(); 

System.out.println(object.toString()); 

例如：String[] aa = "aaa|bbb|ccc".split("\*"); 

for (int i = 0 ; i <aa.length ; i++ ) {

System.out.println("--"+aa[i]); 

} 

public char charAt(int index)

char s = str.charAt(1);

public String toLowerCase()

String newStr = str.toLowerCase();

例如：String s = "xXccxxxXX"; 

// 从头开始查找是否存在指定的字符 //结果如下 

System.out.println(s.indexOf("c")); //2 

// 从第四个字符位置开始往后继续查找，包含当前位置 

System.out.println(s.indexOf("c", 3)); //3 

//若指定字符串中没有该字符则系统返回-1 

System.out.println(s.indexOf("y")); //-1 

System.out.println(s.lastIndexOf("x")); //6 

说到正则表达式，有个例子就能很好的解释replaceAll的用法。即替换空格

String test = "wa n\tg_p\te\tn　g"; 

test = test.replaceAll("\t|\\t|\u0020|\u3000", "");//去掉空格 

System.out.println(test); 

其中test = test.replaceAll("\t|\\t|\u0020|\u3000", "") 

与test = Pattern.compile("\t|\\t|\u0020|\u3000").matcher(test).replaceAll("") 

是等效的，

因此用正则表达式仅仅是替换全部或替换第一个的话，用replaceAll或replaceFirst即可。

String.getBytes(String decode)

byte[] b_gbk = "中".getBytes("GBK");

byte[] b_utf8 = "中".getBytes("UTF-8");

byte[] b_iso88591 = "中".getBytes("ISO8859-1");

将分别返回"中"这个汉字在GBK、UTF-8和ISO8859-1编码下的byte数组表示,此时

b_gbk的长度为2,

b_utf8的长度为3,

b_iso88591的长度为1。

new String(byte[], decode)实际是使用指定的编码decode来将byte[]解析成字符串.

String s_gbk = new String(b_gbk,"GBK");

String s_utf8 = new String(b_utf8,"UTF-8");

String s_iso88591 = new String(b_iso88591,"ISO8859-1");

"构造方法摘要" 
StringBuffer() 
          "构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符。" 
StringBuffer(CharSequence seq) 
          "public java.lang.StringBuilder(CharSequence seq) 构造一个字符串缓冲区，它包含与指定的 			  CharSequence 相同的字符。" 
StringBuffer(int capacity) 
          "构造一个不带字符，但具有指定初始容量的字符串缓冲区。" 
StringBuffer(String str) 
         " 构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。" 

"方法摘要" 
 StringBuffer append(boolean b) 
         " 将 boolean 参数的字符串表示形式追加到序列。" 
 StringBuffer append(char c) 
          "将 char 参数的字符串表示形式追加到此序列。" 
 StringBuffer append(char[] str) 
          "将 char 数组参数的字符串表示形式追加到此序列。" 
 StringBuffer append(char[] str, int offset, int len) 
         " 将 char 数组参数的子数组的字符串表示形式追加到此序列。" 
 StringBuffer append(CharSequence s) 
          "将指定的 CharSequence 追加到该序列。" 
 StringBuffer append(CharSequence s, int start, int end) 
         " 将指定 CharSequence 的子序列追加到此序列。" 
 StringBuffer append(double d) 
         " 将 double 参数的字符串表示形式追加到此序列。 "
 StringBuffer append(float f) 
          "将 float 参数的字符串表示形式追加到此序列。 "
 StringBuffer append(int i) 
         " 将 int 参数的字符串表示形式追加到此序列。" 
 StringBuffer append(long lng) 
          "将 long 参数的字符串表示形式追加到此序列。" 
 StringBuffer append(Object obj) 
         " 追加 Object 参数的字符串表示形式。 "
 StringBuffer append(String str) 
         " 将指定的字符串追加到此字符序列。" 
 StringBuffer append(StringBuffer sb) 
          "将指定的 StringBuffer 追加到此序列中。" 
 StringBuffer appendCodePoint(int codePoint) 
         " 将 codePoint 参数的字符串表示形式追加到此序列。" 
 int capacity() 
          "返回当前容量。" 
 char charAt(int index) 
         " 返回此序列中指定索引处的 char 值。" 
 int codePointAt(int index) 
        "  返回指定索引处的字符（统一代码点）。" 
 int codePointBefore(int index) 
         " 返回指定索引前的字符（统一代码点）。" 
 int codePointCount(int beginIndex, int endIndex) 
         " 返回此序列指定文本范围内的统一代码点。" 
 StringBuffer delete(int start, int end) 
         " 移除此序列的子字符串中的字符。" 
 StringBuffer deleteCharAt(int index) 
         " 移除此序列指定位置的 char。 "
 void ensureCapacity(int minimumCapacity) 
         " 确保容量至少等于指定的最小值。" 
 void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 
         " 将字符从此序列复制到目标字符数组 dst。" 
 int indexOf(String str) 
         " 返回第一次出现的指定子字符串在该字符串中的索引。" 
 int indexOf(String str, int fromIndex) 
         " 从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引。 "
 StringBuffer insert(int offset, boolean b) 
          "将 boolean 参数的字符串表示形式插入此序列中。" 
 StringBuffer insert(int offset, char c) 
         " 将 char 参数的字符串表示形式插入此序列中。 "
 StringBuffer insert(int offset, char[] str) 
         "将 char 数组参数的字符串表示形式插入此序列中。" 
 StringBuffer insert(int index, char[] str, int offset, int len) 
         " 将数组参数 str 的子数组的字符串表示形式插入此序列中。" 
 StringBuffer insert(int dstOffset, CharSequence s) 
         " 将指定 CharSequence 插入此序列中。" 
 StringBuffer insert(int dstOffset, CharSequence s, int start, int end) 
         " 将指定 CharSequence 的子序列插入此序列中。" 
 StringBuffer insert(int offset, double d) 
         " 将 double 参数的字符串表示形式插入此序列中。 "
 StringBuffer insert(int offset, float f) 
         " 将 float 参数的字符串表示形式插入此序列中。 "
 StringBuffer insert(int offset, int i) 
         " 将 int 参数的字符串表示形式插入此序列中。" 
 StringBuffer insert(int offset, long l) 
         " 将 long 参数的字符串表示形式插入此序列中。" 
 StringBuffer insert(int offset, Object obj) 
         " 将 Object 参数的字符串表示形式插入此字符序列中。" 
 StringBuffer insert(int offset, String str) 
         " 将字符串插入此字符序列中。" 
 int lastIndexOf(String str) 
         " 返回最右边出现的指定子字符串在此字符串中的索引。" 
 int lastIndexOf(String str, int fromIndex) 
          "返回最后一次出现的指定子字符串在此字符串中的索引。" 
 int length() 
          "返回长度（字符数）。" 
 int offsetByCodePoints(int index, int codePointOffset) 
         " 返回此序列中的一个索引，该索引是从给定 index 偏移 codePointOffset 个代码点后得到的。 "
 StringBuffer replace(int start, int end, String str) 
         " 使用给定 String 中的字符替换此序列的子字符串中的字符。" 
 StringBuffer reverse() 
          "将此字符序列用其反转形式取代。" 
 void setCharAt(int index, char ch) 
         " 将给定索引处的字符设置为 ch。 "
 void setLength(int newLength) 
          "设置字符序列的长度。" 
 CharSequence subSequence(int start, int end) 
         " 返回一个新的字符序列，该字符序列是此序列的子序列。" 
 String substring(int start) 
         " 返回一个新的 String，它包含此字符序列当前所包含的字符子序列。" 
 String substring(int start, int end) 
         " 返回一个新的 String，它包含此序列当前所包含的字符子序列。 "
 String toString() 
          "返回此序列中数据的字符串表示形式。 "
 void trimToSize() 
          "尝试减少用于字符序列的存储空间。 "

构造方法摘要 
String() 
          "初始化一个新创建的 String 对象，使其表示一个空字符序列。" 
String(byte[] bytes) 
          "通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。 "
String(byte[] bytes, Charset charset) 
          "通过使用指定的 charset 解码指定的 byte 数组，构造一个新的 String。 "
String(byte[] ascii, int hibyte) 
          "已过时。 该方法无法将字节正确地转换为字符。从 JDK 1.1 开始，完成该转换的首选方法是使用带有 		   Charset、字符集名称，或使用平台默认字符集的 String 构造方法。" 
String(byte[] bytes, int offset, int length) 
          "通过使用平台的默认字符集解码指定的 byte 子数组，构造一个新的 String。 "
String(byte[] bytes, int offset, int length, Charset charset) 
          "通过使用指定的 charset 解码指定的 byte 子数组，构造一个新的 String。"
String(byte[] ascii, int hibyte, int offset, int count) 
          "已过时。 该方法无法将字节正确地转换为字符。从 JDK 1.1 开始，完成该转换的首选方法是使用带有 		   Charset、字符集名称，或使用平台默认字符集的 String 构造方法。" 
String(byte[] bytes, int offset, int length, String charsetName) 
          "通过使用指定的字符集解码指定的 byte 子数组，构造一个新的 String。 "
String(byte[] bytes, String charsetName) 
         " 通过使用指定的 charset 解码指定的 byte 数组，构造一个新的 String。" 
String(char[] value) 
         " 分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。 "
String(char[] value, int offset, int count) 
         " 分配一个新的 String，它包含取自字符数组参数一个子数组的字符。 "
String(int[] codePoints, int offset, int count) 
          "分配一个新的 String，它包含 Unicode 代码点数组参数一个子数组的字符。" 
String(String original) 
         " 初始化一个新创建的 String 对象，使其表示一个与参数相同的字符序列；换句话说，新创建的字符串是		  该参数字符串的副本。" 
String(StringBuffer buffer) 
         " 分配一个新的字符串，它包含字符串缓冲区参数中当前包含的字符序列。 "
String(StringBuilder builder) 
          "分配一个新的字符串，它包含字符串生成器参数中当前包含的字符序列。 "

方法摘要 
 char charAt(int index) 
         " 返回指定索引处的 char 值。" 
 int codePointAt(int index) 
          "返回指定索引处的字符（Unicode 代码点）。 "
 int codePointBefore(int index) 
         " 返回指定索引之前的字符（Unicode 代码点）。" 
 int codePointCount(int beginIndex, int endIndex) 
         " 返回此 String 的指定文本范围中的 Unicode 代码点数。 "
 int compareTo(String anotherString) 
          "按字典顺序比较两个字符串。" 
 int compareToIgnoreCase(String str) 
         " 按字典顺序比较两个字符串，不考虑大小写。" 
 String concat(String str) 
          "将指定字符串连接到此字符串的结尾。" 
 boolean contains(CharSequence s) 
          "当且仅当此字符串包含指定的 char 值序列时，返回 true。 "
 boolean contentEquals(CharSequence cs) 
         " 将此字符串与指定的 CharSequence 比较。" 
 boolean contentEquals(StringBuffer sb) 
         " 将此字符串与指定的 StringBuffer 比较。 "
static String copyValueOf(char[] data) 
         " 返回指定数组中表示该字符序列的 String。" 
static String copyValueOf(char[] data, int offset, int count) 
          "返回指定数组中表示该字符序列的 String。" 
 boolean endsWith(String suffix) 
          "测试此字符串是否以指定的后缀结束。 "
 boolean equals(Object anObject) 
         " 将此字符串与指定的对象比较。" 
 boolean equalsIgnoreCase(String anotherString) 
         " 将此 String 与另一个 String 比较，不考虑大小写。" 
static String format(Locale l, String format, Object... args) 
         " 使用指定的语言环境、格式字符串和参数返回一个格式化字符串。" 
static String format(String format, Object... args) 
          "使用指定的格式字符串和参数返回一个格式化字符串。" 
 byte[] getBytes() 
          "使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。" 
 byte[] getBytes(Charset charset) 
          "使用给定的 charset 将此 String 编码到 byte 序列，并将结果存储到新的 byte 数组。" 
 void getBytes(int srcBegin, int srcEnd, byte[] dst, int dstBegin) 
         " 已过时。 该方法无法将字符正确转换为字节。从 JDK 1.1 起，完成该转换的首选方法是通过 				  getBytes() 方法，该方法使用平台的默认字符集。" 
 byte[] getBytes(String charsetName) 
         " 使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。" 
 void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 
          "将字符从此字符串复制到目标字符数组。" 
 int hashCode() 
         " 返回此字符串的哈希码。" 
 int indexOf(int ch) 
          "返回指定字符在此字符串中第一次出现处的索引。" 
 int indexOf(int ch, int fromIndex) 
          "返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。" 
 int indexOf(String str) 
         " 返回指定子字符串在此字符串中第一次出现处的索引。" 
 int indexOf(String str, int fromIndex) 
          "返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。" 
 String intern() 
          "返回字符串对象的规范化表示形式。" 
 boolean isEmpty() 
         " 当且仅当 length() 为 0 时返回 true。 "
 int lastIndexOf(int ch) 
          "返回指定字符在此字符串中最后一次出现处的索引。 "
 int lastIndexOf(int ch, int fromIndex) 
          "返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。" 
 int lastIndexOf(String str) 
          "返回指定子字符串在此字符串中最右边出现处的索引。" 
 int lastIndexOf(String str, int fromIndex) 
         " 返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。 "
 int length() 
         " 返回此字符串的长度。 "
 boolean matches(String regex) 
         " 告知此字符串是否匹配给定的正则表达式。" 
 int offsetByCodePoints(int index, int codePointOffset) 
          "返回此 String 中从给定的 index 处偏移 codePointOffset 个代码点的索引。" 
 boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len) 
          "测试两个字符串区域是否相等。" 
 boolean regionMatches(int toffset, String other, int ooffset, int len) 
         " 测试两个字符串区域是否相等。 "
 String replace(char oldChar, char newChar) 
         " 返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。" 
 String replace(CharSequence target, CharSequence replacement) 
         " 使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。 "
 String replaceAll(String regex, String replacement) 
          "使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。" 
 String replaceFirst(String regex, String replacement) 
          "使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。 "
 String[] split(String regex) 
          "根据给定正则表达式的匹配拆分此字符串。 "
 String[] split(String regex, int limit) 
          "根据匹配给定的正则表达式来拆分此字符串。" 
 boolean startsWith(String prefix) 
          "测试此字符串是否以指定的前缀开始。" 
 boolean startsWith(String prefix, int toffset) 
          "测试此字符串从指定索引开始的子字符串是否以指定前缀开始。" 
 CharSequence subSequence(int beginIndex, int endIndex) 
          "返回一个新的字符序列，它是此序列的一个子序列。" 
 String substring(int beginIndex) 
         " 返回一个新的字符串，它是此字符串的一个子字符串。 "
 String substring(int beginIndex, int endIndex) 
         " 返回一个新字符串，它是此字符串的一个子字符串。 "
 char[] toCharArray() 
        "  将此字符串转换为一个新的字符数组。 "
 String toLowerCase() 
         " 使用默认语言环境的规则将此 String 中的所有字符都转换为小写。 "
 String toLowerCase(Locale locale) 
         " 使用给定 Locale 的规则将此 String 中的所有字符都转换为小写。" 
 String toString() 
         " 返回此对象本身（它已经是一个字符串！）。 "
 String toUpperCase() 
          "使用默认语言环境的规则将此 String 中的所有字符都转换为大写。 "
 String toUpperCase(Locale locale) 
         " 使用给定 Locale 的规则将此 String 中的所有字符都转换为大写。 "
 String trim() 
         " 返回字符串的副本，忽略前导空白和尾部空白。" 
static String valueOf(boolean b) 
          "返回 boolean 参数的字符串表示形式。" 
static String valueOf(char c) 
          "返回 char 参数的字符串表示形式。" 
static String valueOf(char[] data) 
         " 返回 char 数组参数的字符串表示形式。" 
static String valueOf(char[] data, int offset, int count) 
          "返回 char 数组参数的特定子数组的字符串表示形式。" 
static String valueOf(double d) 
         " 返回 double 参数的字符串表示形式。" 
static String valueOf(float f) 
          "返回 float 参数的字符串表示形式。" 
static String valueOf(int i) 
          "返回 int 参数的字符串表示形式。" 
static String valueOf(long l) 
         " 返回 long 参数的字符串表示形式。 "
static String valueOf(Object obj) 
          "返回 Object 参数的字符串表示形式。 "

public static boolean isEmpty(String str) 
   "判断某字符串是否为空，为空的标准是 str==null 或 str.length()==0 "
public static boolean isNotEmpty(String str) 
   "判断某字符串是否非空，等于 !isEmpty(String str) "
public static boolean isBlank(String str) 
  " 判断某字符串是否为空或长度为0或由空白符(whitespace) 构成"
public static boolean isNotBlank(String str) 
   "判断某字符串是否不为空且长度不为0且不由空白符(whitespace) 构成，等于 !isBlank(String str) "
public static String trim(String str) 
   "去掉字符串两端的控制符(control characters, char <= 32) , 如果输入为 null 则返回null "
public static String trimToNull(String str) 
   "去掉字符串两端的控制符(control characters, char <= 32) ,如果变为 null 或""，则返回 null "
public static String trimToEmpty(String str) 
   "去掉字符串两端的控制符(control characters, char <= 32) ,如果变为 null 或 "" ，则返回 "" "
public static String strip(String str) 
   "去掉字符串两端的空白符(whitespace) ，如果输入为 null 则返回 null "
public static String stripToNull(String str) 
   "去掉字符串两端的空白符(whitespace) ，如果变为 null 或""，则返回 null "
public static String stripToEmpty(String str) 
    "去掉字符串两端的空白符(whitespace) ，如果变为 null 或"" ，则返回"" "
public static String strip(String str, String stripChars) 
   "去掉 str 两端的在 stripChars 中的字符。"
public static String stripStart(String str, String stripChars) 
    "和11相似，去掉 str 前端的在 stripChars 中的字符。"
public static String stripEnd(String str, String stripChars) 
   " 和11相似，去掉 str 末端的在 stripChars 中的字符。"
public static String[] stripAll(String[] strs) 
   " 对字符串数组中的每个字符串进行 strip(String str) ，然后返回。"
public static String[] stripAll(String[] strs, String stripChars) 
    "对字符串数组中的每个字符串进行 strip(String str, String stripChars) ，然后返回。"
public static boolean equals(String str1, String str2) 
   " 比较两个字符串是否相等，如果两个均为空则也认为相等。"
public static boolean equalsIgnoreCase(String str1, String str2) 
   " 比较两个字符串是否相等，不区分大小写，如果两个均为空则也认为相等。"
public static int indexOf(String str, char searchChar) 
    "返回字符 searchChar 在字符串 str 中第一次出现的位置。"
public static int indexOf(String str, char searchChar, int startPos) 
   " 返回字符 searchChar 从 startPos 开始在字符串 str 中第一次出现的位置。"
public static int indexOf(String str, String searchStr) 
   " 返回字符串 searchStr 在字符串 str 中第一次出现的位置。"
public static int ordinalIndexOf(String str, String searchStr, int ordinal) 
    "返回字符串 searchStr 在字符串 str 中第 ordinal 次出现的位置。"
public static int indexOf(String str, String searchStr, int startPos) 
   " 返回字符串 searchStr 从 startPos 开始在字符串 str 中第一次出现的位置。"

public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner s=new Scanner(System.in);
		int a,b;
		a=s.nextInt();
		System.out.println(a);
		b=s.nextInt();
		System.out.println(b);
		/*a=s.nextInt();
		b=s.nextInt();
		System.out.println(a+"  "+b);*/
	}
/*
第一种情况
2 3
2
3
*/
/*
第二种情况
2
2
3
3
*/

int a = 100;
if(a == 100) {
    System.out.println(a);
}

public class Getifelse {

    public static void main(String[] args) {
        int math = 80;        // 声明，数学成绩为80（及格）
        int english = 50;    // 声明，英语成绩为50（不及格）
        
        if(math >= 60) {    // if判断语句判断math是否大于等于60
            System.out.println("math has passed");
        } else {            // if条件不成立
            System.out.println("math has not passed");
        }
        
        if(english >= 60) {    // if判断语句判断english是否大于等于60
            System.out.println("english has passed");
        } else {            // if条件不成立
            System.out.println("english has not passed");
        }
    }

}

public class GetTerm {

    public static void main(String[] args) {
        int x = 40;
        
        if(x > 60) {
            System.out.println("x的值大于60");
        } else if (x > 30) {
            System.out.println("x的值大于30但小于60");
        } else if (x > 0) {
            System.out.println("x的值大于0但小于30");
        } else {
            System.out.println("x的值小于等于0");
        }
    }

}

switch(表达式)
{ 
 case 常量值1:
        语句块1
        [break;]
...
case 常量值n:
        语句块2
        [break;]
default:
        语句块 n+1;
        [break;]
}

public class GetSum {

    public static void main(String[] args) {
        int x = 1;            // 定义初值
        int sum = 0;        // 定义求和变量，用于存储相加后的结果
        
        while(x <= 10) {
            sum += x;        // 循环相加，也即    sum = sum + x;
            x++;
        }
        System.out.println(sum);
    }
  /*
  这就是一个从1加到10的代码，首先定义一个初值x为1，然后定义一个存储相加结果的变量sum为0，循环条件为x<=10，也就是每次判断x<=10是否成立，成立则继续循环。循环内第一句“sum +=x;”其实就是“sum = sum +x;”的另一种写法，是在sum的基础上加x，并赋给sum，那么此时sum的值为0+1=1了，然后x++，x自增1为2，判断x<=10，则继续循环，sum的值变为1+2=3，然后x++变为3，如此循环下去，直到x为11时退出循环，此时sum的值就是1+2+3+4+5+6+7+8+9+10最后的结果55了。
  */

}

do
{
    执行语句
}  while (条件表达式);

public class Cycle {

    public static void main(String[] args) {
        int a = 10;
        int b = 10;
        
        // while循环语句
        while(a == 8) {
            System.out.println("a == " + a);
            a--;
        }
        
        // do···while循环语句
        do {
            System.out.println("b == " + b);
            b--;
        } while(b == 8);
    }

}

for(表达式1; 表达式2; 表达式3)
{
    语句序列
}

public class Circulate {

    public static void main(String[] args) {
        int sum = 0;
        
        for(int i=2; i<=100; i+=2) {
            sum += i;
        }
        
        System.out.println(sum);
    }
/*
例：用for循环语句求100以内所有偶数的和。
for循环内，首先定义一个变量并赋初值，表示循环中i从2开始进行，然后条件为i<=100，即i<=100时进行循环并执行语句块中的语句，第三个表达式“i+=2”表示每次循环执行i=i+1，即没循环一次，i的值为在原来的基础上加2后的值。然后循环求sum的值，即2+4+6+8+···+100，当i=102时退出循环，执行输出语句，输出结果为2550。
*/
}

for(元素变量x : 遍历对象obj) {
    引用了x的Java语句;
}

int array[] = {7, 8, 9};
/*
array是一个一维数组，其中有7、8、9三个值，现在要将这三个值打印到控制台上，用foreach语句相比for语句会简单很多。其中，在for的条件中，先定义了一个整型变量arr（只要和要遍历的数组名不同即可），冒号后则是要遍历的数组名，那么｛｝间就是要循环的内容了。
*/
for (int arr : array) {
     System.out.println(arr);
}

for(int i=0; i<n; i++) {    // 外层循环
    for(int j=0; j<n ;j++) {    // 内层循环
        break;
    }
}

public class ContinueDemo {

    public static void main(String[] args) {
        int i = 0;
        
        while(i < 10) {
            i++;
            
            if(i%2 == 0) {    // 能被2整除，是偶数
                continue;    // 跳过当前循环
            }
            
            System.out.print(i + " ");    
        }
    }
//例：输出10以内的所有奇数
  /*这里if条件判断是否为偶数，如果是偶数则执行continue，直接跳出本次循环，不进行continue后的步骤（即不执行输出语句），然后下一次循环为奇数，输出i*/
}

public void getName() {
    return name;
}
//这是一个方法用于获取姓名，当调用这个方法时将返回姓名值。

String[] aArray = new String[5];
String[] bArray = {"a","b","c", "d", "e"};
String[] cArray = new String[]{"a","b","c","d","e"};

int[] intArray = { 1, 2, 3, 4, 5 };
String intArrayString = Arrays.toString(intArray);
// print directly will print reference value
System.out.println(intArray);
// [I@7150bd4d
System.out.println(intArrayString);
// [1, 2, 3, 4, 5]

String[] stringArray = { "a", "b", "c", "d", "e" };
ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(stringArray));
System.out.println(arrayList);
// [a, b, c, d, e]

String[] stringArray = { "a", "b", "c", "d", "e" };
boolean b = Arrays.asList(stringArray).contains("a");
System.out.println(b);
// true

int[] intArray = { 1, 2, 3, 4, 5 };
int[] intArray2 = { 6, 7, 8, 9, 10 };
// Apache Commons Lang library
int[] combinedIntArray = ArrayUtils.addAll(intArray, intArray2);

method(new String[]{"a", "b", "c", "d", "e"});

// containing the provided list of elements
// Apache common lang
String j = StringUtils.join(new String[] { "a", "b", "c" }, ", ");
System.out.println(j);
// a, b, c

String[] stringArray = { "a", "b", "c", "d", "e" };
ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(stringArray));
String[] stringArr = new String[arrayList.size()];
arrayList.toArray(stringArr);
for (String s : stringArr)
    System.out.println(s);

Set<String> set = new HashSet<String>(Arrays.asList(stringArray));
System.out.println(set);
//[d, e, b, c, a]

int[] intArray = { 1, 2, 3, 4, 5 };
ArrayUtils.reverse(intArray);
System.out.println(Arrays.toString(intArray));
//[5, 4, 3, 2, 1]

int[] intArray = { 1, 2, 3, 4, 5 };
int[] removed = ArrayUtils.removeElement(intArray, 3);//create a new array
System.out.println(Arrays.toString(removed));

byte[] bytes = ByteBuffer.allocate(4).putInt(8).array();
for (byte t : bytes) {
    System.out.format("0x%x ", t);
}

//用指定元素填充整个数组（会替换掉数组中原来的元素）
//Arrays.fill(Object[] array, Object obj)
Integer[] data = {1, 2, 3, 4};
Arrays.fill(data, 9);
System.out.println(Arrays.toString(data)); // [9, 9, 9, 9]

//用指定元素填充数组，从起始位置到结束位置，取头不取尾（会替换掉数组中原来的元素）
//Arrays.fill(Object[] array, int fromIndex, int toIndex, Object obj)
Integer[] data = {1, 2, 3, 4};
Arrays.fill(data, 0, 2, 9);
System.out.println(Arrays.toString(data)); // [9, 9, 3, 4]

//Arrays.sort(Object[] array)
//对数组元素进行排序（串行排序）
String[] data = {"1", "4", "3", "2"};
System.out.println(Arrays.toString(data)); // [1, 4, 3, 2]
Arrays.sort(data);
System.out.println(Arrays.toString(data)); // [1, 2, 3, 4]

//Arrays.sort(T[] array, Comparator<? super T> comparator)
//使用自定义比较器，对数组元素进行排序（串行排序）
String[] data = {"1", "4", "3", "2"};
System.out.println(Arrays.toString(data)); // [1, 4, 3, 2]
// 实现降序排序，返回-1放左边，1放右边，0保持不变
Arrays.sort(data, (str1, str2) -> {
    if (str1.compareTo(str2) > 0) {
        return -1;
    } else {
        return 1;
    }
});
System.out.println(Arrays.toString(data)); // [4, 3, 2, 1]


//Arrays.sort(Object[] array, int fromIndex, int toIndex)
//对数组元素的指定范围进行排序（串行排序）
String[] data = {"1", "4", "3", "2"};
System.out.println(Arrays.toString(data)); // [1, 4, 3, 2]
// 对下标[0, 3)的元素进行排序，即对1，4，3进行排序，2保持不变
Arrays.sort(data, 0, 3);
System.out.println(Arrays.toString(data)); // [1, 3, 4, 2]

/*Arrays.sort(T[] array, int fromIndex, int toIndex, Comparator<? super T> c)*/
//使用自定义比较器，对数组元素的指定范围进行排序（串行排序）
String[] data = {"1", "4", "3", "2"};
System.out.println(Arrays.toString(data)); // [1, 4, 3, 2]
// 对下标[0, 3)的元素进行降序排序，即对1，4，3进行降序排序，2保持不变
Arrays.sort(data, 0, 3, (str1, str2) -> {
    if (str1.compareTo(str2) > 0) {
        return -1;
    } else {
        return 1;
    }
});
System.out.println(Arrays.toString(data)); // [4, 3, 1, 2]

//Arrays.copyOf(T[] original, int newLength)
/*拷贝数组，其内部调用了 System.arraycopy() 方法，从下标0开始，如果超过原数组长度，会用null进行填充*/
Integer[] data1 = {1, 2, 3, 4};
Integer[] data2 = Arrays.copyOf(data1, 2);
System.out.println(Arrays.toString(data2)); // [1, 2]
Integer[] data2 = Arrays.copyOf(data1, 5);
System.out.println(Arrays.toString(data2)); // [1, 2, 3, 4, null]


//Arrays.copyOfRange(T[] original, int from, int to)
//拷贝数组，指定起始位置和结束位置，如果超过原数组长度，会用null进行填充
Integer[] data1 = {1, 2, 3, 4};
Integer[] data2 = Arrays.copyOfRange(data1, 0, 2);
System.out.println(Arrays.toString(data2)); // [1, 2]
Integer[] data2 = Arrays.copyOfRange(data1, 0, 5);
System.out.println(Arrays.toString(data2)); // [1, 2, 3, 4, null]

//Arrays.equals(Object[] array1, Object[] array2)
/*判断两个数组是否相等，实际上比较的是两个数组的哈希值，即 Arrays.hashCode(data1) == Arrays.hashCode(data2)*/
Integer[] data1 = {1, 2, 3};
Integer[] data2 = {1, 2, 3};
System.out.println(Arrays.equals(data1, data2)); // true

//Arrays.hashCode(Object[] array)
//返回数组的哈希值
Integer[] data = {1, 2, 3};
System.out.println(Arrays.hashCode(data)); // 30817

static <T> List<T> asList(T... a) 
          "返回一个受指定数组支持的固定大小的列表。" 
static void fill(Object[] a, Object val) 
         " 将指定的 Object 引用分配给指定 Object 数组的每个元素。 "
static void fill(Object[] a, int fromIndex, int toIndex, Object val) 
          "将指定的 Object 引用分配给指定 Object 数组指定范围中的每个元素。" 
static void sort(Object[] a) 
         " 根据元素的自然顺序对指定对象数组按升序进行排序。" 
static void sort(Object[] a, int fromIndex, int toIndex) 
          "根据元素的自然顺序对指定对象数组的指定范围按升序进行排序。" 
static <T> void sort(T[] a, Comparator<? super T> c) 
          "根据指定比较器产生的顺序对指定对象数组进行排序。" 
static <T> void sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c) 
          "根据指定比较器产生的顺序对指定对象数组的指定范围进行排序。" 
static <T> T[] copyOf(T[] original, int newLength) 
          "复制指定的数组，截取或用 null 填充（如有必要），以使副本具有指定的长度。" 
static <T> T[] copyOfRange(T[] original, int from, int to) 
         " 将指定数组的指定范围复制到一个新数组。" 
static boolean equals(Object[] a, Object[] a2) 
          "如果两个指定的 Objects 数组彼此相等，则返回 true。" 
static int hashCode(Object[] a) 
          "基于指定数组的内容返回哈希码。" 
static String toString(Object[] a) 
          "返回指定数组内容的字符串表示形式。" 
static int binarySearch(Object[] a, Object key) 
          "使用二分搜索法来搜索指定数组，以获得指定对象。但是要先排序 "

// *************排序 sort****************
		int a[] = { 1, 3, 2, 7, 6, 5, 4, 9 };
		// sort(int[] a)方法按照数字顺序排列指定的数组。
		Arrays.sort(a);
		System.out.println("Arrays.sort(a):");
		for (int i : a) {
			System.out.print(i);
		}
		// 换行
		System.out.println();

		// sort(int[] a,int fromIndex,int toIndex)按升序排列数组的指定范围
		int b[] = { 1, 3, 2, 7, 6, 5, 4, 9 };
		Arrays.sort(b, 2, 6);
		System.out.println("Arrays.sort(b, 2, 6):");
		for (int i : b) {
			System.out.print(i);
		}
		// 换行
		System.out.println();

		int c[] = { 1, 3, 2, 7, 6, 5, 4, 9 };
		// parallelSort(int[] a) 按照数字顺序排列指定的数组(并行的)。同sort方法一样也有按范围的排序
		Arrays.parallelSort(c);
		System.out.println("Arrays.parallelSort(c)：");
		for (int i : c) {
			System.out.print(i);
		}
		// 换行
		System.out.println();

		// parallelSort给字符数组排序，sort也可以
		char d[] = { 'a', 'f', 'b', 'c', 'e', 'A', 'C', 'B' };
		Arrays.parallelSort(d);
		System.out.println("Arrays.parallelSort(d)：");
		for (char d2 : d) {
			System.out.print(d2);
		}
		// 换行
		System.out.println();

// *************查找 binarySearch()****************
		char[] e = { 'a', 'f', 'b', 'c', 'e', 'A', 'C', 'B' };
		// 排序后再进行二分查找，否则找不到
		Arrays.sort(e);
		System.out.println("Arrays.sort(e)" + Arrays.toString(e));
		System.out.println("Arrays.binarySearch(e, 'c')：");
		int s = Arrays.binarySearch(e, 'c');
		System.out.println("字符c在数组的位置：" + s);

// *************比较 equals****************
		char[] e = { 'a', 'f', 'b', 'c', 'e', 'A', 'C', 'B' };
		char[] f = { 'a', 'f', 'b', 'c', 'e', 'A', 'C', 'B' };
		/*
		* 元素数量相同，并且相同位置的元素相同。 另外，如果两个数组引用都是null，则它们被认为是相等的 。
		*/
		// 输出true
		System.out.println("Arrays.equals(e, f):" + Arrays.equals(e, f));

// *************填充fill(批量初始化)****************
		int[] g = { 1, 2, 3, 3, 3, 3, 6, 6, 6 };
		// 数组中所有元素重新分配值
		Arrays.fill(g, 3);
		System.out.println("Arrays.fill(g, 3)：");
		// 输出结果：333333333
		for (int i : g) {
			System.out.print(i);
		}
		// 换行
		System.out.println();

		int[] h = { 1, 2, 3, 3, 3, 3, 6, 6, 6, };
		// 数组中指定范围元素重新分配值
		Arrays.fill(h, 0, 2, 9);
		System.out.println("Arrays.fill(h, 0, 2, 9);：");
		// 输出结果：993333666
		for (int i : h) {
			System.out.print(i);
		}

// *************转列表 asList()****************
		/*
		 * 返回由指定数组支持的固定大小的列表。
		 * （将返回的列表更改为“写入数组”。）该方法作为基于数组和基于集合的API之间的桥梁，与Collection.toArray()相结合 。
		 * 返回的列表是可序列化的，并实现RandomAccess 。
		 * 此方法还提供了一种方便的方式来创建一个初始化为包含几个元素的固定大小的列表如下：
		 */
		List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");
		System.out.println(stooges);

// *************转字符串 toString()****************
		/*
		* 返回指定数组的内容的字符串表示形式。
		*/
		char[] k = { 'a', 'f', 'b', 'c', 'e', 'A', 'C', 'B' };
		System.out.println(Arrays.toString(k));// [a, f, b, c, e, A, C, B]

// *************复制 copy****************
		// copyOf 方法实现数组复制,h为数组，6为复制的长度
		int[] h = { 1, 2, 3, 3, 3, 3, 6, 6, 6, };
		int i[] = Arrays.copyOf(h, 6);
		System.out.println("Arrays.copyOf(h, 6);：");
		// 输出结果：123333
		for (int j : i) {
			System.out.print(j);
		}
		// 换行
		System.out.println();
		// copyOfRange将指定数组的指定范围复制到新数组中
		int j[] = Arrays.copyOfRange(h, 6, 11);
		System.out.println("Arrays.copyOfRange(h, 6, 11)：");
		// 输出结果66600(h数组只有9个元素这里是从索引6到索引11复制所以不足的就为0)
		for (int j2 : j) {
			System.out.print(j2);
		}
		// 换行
		System.out.println();

int[] myArray = { 1, 2, 3 };
List myList = Arrays.asList(myArray);//相当于list中放了一个array数组
System.out.println(myList.size());//1，里面只有一个数组
System.out.println(myList.get(0));//数组地址值
System.out.println(myList.get(1));//报错：ArrayIndexOutOfBoundsException
int [] array=(int[]) myList.get(0);
System.out.println(array[0]);//1
System.out.println(array[1]);//2
System.out.println(array[2]);//3

//应该使用Integer[] myArray = { 1, 2, 3 };

List myList = Arrays.asList(1, 2, 3);
myList.add(4);//运行时报错：UnsupportedOperationException
myList.remove(1);//运行时报错：UnsupportedOperationException
myList.clear();//运行时报错：UnsupportedOperationException
System.out.println(myList.getClass());//class java.util.Arrays$ArrayList

//JDK1.5+
static <T> List<T> arrayToList(final T[] array) {
  final List<T> l = new ArrayList<T>(array.length);

  for (final T s : array) {
    l.add(s);
  }
  return (l);
}

Integer [] myArray = { 1, 2, 3 };
System.out.println(arrayToList(myArray).getClass());//class java.util.ArrayList

List list = new ArrayList<>(Arrays.asList("a", "b", "c"));

Integer [] myArray = { 1, 2, 3 };
List myList = Arrays.stream(myArray).collect(Collectors.toList());
//基本类型也可以实现转换（依赖boxed的装箱操作）
int [] myArray2 = { 1, 2, 3 };
List myList = Arrays.stream(myArray2).boxed().collect(Collectors.toList());

/*
对于不可变集合，你可以使用ImmutableList类及其of()与copyOf()工厂方法：（参数不能为空）
*/
List<String> il = ImmutableList.of("string", "elements");  // from varargs
List<String> il = ImmutableList.copyOf(aStringArray);      // from array

//对于可变集合，你可以使用Lists类及其newArrayList()工厂方法：
List<String> l1 = Lists.newArrayList(anotherListOrCollection);    // from collection
List<String> l2 = Lists.newArrayList(aStringArray);               // from array
List<String> l3 = Lists.newArrayList("or", "string", "elements"); // from varargs

List<String> list = new ArrayList<String>();
CollectionUtils.addAll(list, str);

static String	toString(Object array) 
          "将数组作为String输出，null视为空数组。"
static Map	toMap(Object[] array) 
         " 将给定数组转换为Map。"
static Object[]	clone(Object[] array) 
         " Shallow克隆返回类型转换结果和处理的数组 null。"
static Object[]	subarray(Object[] array, int startIndexInclusive, int endIndexExclusive) 
          "生成一个包含开始和结束索引之间元素的新数组。"
static boolean	isSameLength(Object[] array1, Object[] array2) 
          "检查两个数组是否长度相同，将 null数组视为长度0。"
static boolean	isSameType(Object array1, Object array2) 
          "考虑多维数组，检查两个数组是否是同一类型。"
static int	getLength(Object array) 
          "返回指定数组的长度。"
static void	reverse(Object[] array) 
         " 反转给定数组的顺序。"
static int	indexOf(Object[] array, Object objectToFind, int startIndex) 
          "从给定索引开始查找数组中给定对象的索引。"
static boolean	contains(Object[] array, Object objectToFind) 
          "检查对象是否在给定的数组中。"
static Integer[]	toObject(int[] array) 
          "将原始int数组转换为对象。"
static boolean	isEmpty(Object[] array) 
          "检查对象数组是否为空或null。"
static Object[]	addAll(Object[] array1, Object[] array2) 
          "将给定数组的所有元素添加到新数组中。"
static Object[]	add(Object[] array, int index, Object element) 
         " 将指定元素插入数组中的指定位置。"
static Object[]	remove(Object[] array, int index) 
          "从指定的数组中删除指定位置的元素。"
static Object[]	removeElement(Object[] array, Object element) 
         " 从指定的数组中删除指定元素的第一个匹配项。"

Employee e;
e=new Employee();
e=new Manager();
//可以将一个子类的对象赋值给超类变量

Manager[] manages=new Manager[10];
//将他转换成Employee[]数组是合法的
Employee[]staff=manages;

Manager boss=(Manager)staff[0];

if(staff[1] instanceof Manager)
{
  boss=(Manager)staff[1];
}

Object obj=new Employee();

Employee[]staff=new Employee[10];
obj=staff;
obj=new int[10];

if(this==otherobject) return true;

if(otherobject==null) return false;

if(getClass()!=otherobject.getClass()) return false;

if(!(otherobject instanceof ClassName)) return false;

ClassName other =(ClassName) otherobject

return filed1==other.filed1 && Objects.equals(filed2,other.filed2)

方法摘要 
protected  Object clone() 
          "创建并返回此对象的一个副本。" 
 boolean equals(Object obj) 
         " 指示其他某个对象是否与此对象“相等”。" 
protected  void finalize() 
          "当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。 "
 Class<?> getClass() 
         " 返回此 Object 的运行时类。" 
 int hashCode() 
         " 返回该对象的哈希码值。" 
 void notify() 
          "唤醒在此对象监视器上等待的单个线程。" 
 void notifyAll() 
         " 唤醒在此对象监视器上等待的所有线程。 "
 String toString() 
         " 返回该对象的字符串表示。" 
 void wait() 
         " 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。 "
 void wait(long timeout) 
          "在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量前，导致当前线			  程等待。" 
 void wait(long timeout, int nanos) 
         " 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者其他某个线程中断当前线程，或者			  已超过某个实际时间量前，导致当前线程等待。" 

// Collection中定义的API
boolean             add(E object)
boolean             addAll(Collection<? extends E> collection)
void                clear()
boolean             contains(Object object)
boolean             containsAll(Collection<?> collection)
boolean             equals(Object object)
int                 hashCode()
boolean             isEmpty()
Iterator<E>         iterator()
boolean             remove(Object object)
boolean             removeAll(Collection<?> collection)
boolean             retainAll(Collection<?> collection)
int                 size()
<T> T[]             toArray(T[] array)
Object[]            toArray()
// AbstractCollection中定义的API
void                add(int location, E object)
boolean             addAll(int location, Collection<? extends E> collection)
E                   get(int location)
int                 indexOf(Object object)
int                 lastIndexOf(Object object)
ListIterator<E>     listIterator(int location)
ListIterator<E>     listIterator()
E                   remove(int location)
E                   set(int location, E object)
List<E>             subList(int start, int end)
// ArrayList新增的API
Object               clone()
void                 ensureCapacity(int minimumCapacity)
void                 trimToSize()
void                 removeRange(int fromIndex, int toIndex)

boolean add(E e) 
          "将指定的元素添加到此列表的尾部。" 
 void add(int index, E element) 
          "将指定的元素插入此列表中的指定位置。" 
 boolean addAll(Collection<? extends E> c) 
         " 按照指定 collection 的迭代器所返回的元素顺序，将该 collection 中的所有元素添加到此列表的尾			部。 "
 boolean addAll(int index, Collection<? extends E> c) 
         "从指定的位置开始，将指定 collection 中的所有元素插入到此列表中。" 
 void clear() 
          "移除此列表中的所有元素。" 
 Object clone() 
         " 返回此 ArrayList 实例的浅表副本。" 
 boolean contains(Object o) 
         " 如果此列表中包含指定的元素，则返回 true。" 
 void ensureCapacity(int minCapacity) 
         " 如有必要，增加此 ArrayList 实例的容量，以确保它至少能够容纳最小容量参数所指定的元素数。" 
 E get(int index) 
          "返回此列表中指定位置上的元素。" 
 int indexOf(Object o) 
          "返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。" 
 boolean isEmpty() 
         " 如果此列表中没有元素，则返回 true "
 int lastIndexOf(Object o) 
          "返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。" 
 E remove(int index) 
         " 移除此列表中指定位置上的元素。" 
 boolean remove(Object o) 
         " 移除此列表中首次出现的指定元素（如果存在）。 "
protected  void removeRange(int fromIndex, int toIndex) 
         " 移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素。" 
 E set(int index, E element) 
         " 用指定的元素替代此列表中指定位置上的元素。 "
 int size() 
         " 返回此列表中的元素数。 "
 Object[] toArray() 
         " 按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组。" 
<T> T[] toArray(T[] a) 
          "按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组；返回数组的运行时类型是指			定数组的运行时类型。" 
 void trimToSize() 
         " 将此 ArrayList 实例的容量调整为列表的当前大小。" 

ArrayList<Integer> list=new ArrayList<>();
list.add(3);
//自动变换成
list.add(Integer.valueOf(3));

int n=list.get(i);
//自动转换为
int n=list.get(i).intValue();

字段摘要 
static int MAX_VALUE 
         " 值为 231－1 的常量，它表示 int 类型能够表示的最大值。" 
static int MIN_VALUE 
          "值为 －231 的常量，它表示 int 类型能够表示的最小值。 "
static int SIZE 
          "用来以二进制补码形式表示 int 值的比特位数。 "
static Class<Integer> TYPE 
         " 表示基本类型 int 的 Class 实例。 "

构造方法摘要 
Integer(int value) 
        "  构造一个新分配的 Integer 对象，它表示指定的 int 值。" 
Integer(String s) 
         " 构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。 "

方法摘要 
static int bitCount(int i) 
          "返回指定 int 值的二进制补码表示形式的 1 位的数量。 "
 byte byteValue() 
         " 以 byte 类型返回该 Integer 的值。" 
 int compareTo(Integer anotherInteger) 
         " 在数字上比较两个 Integer 对象。" 
static Integer decode(String nm) 
         " 将 String 解码为 Integer。" 
 double doubleValue() 
          "以 double 类型返回该 Integer 的值。" 
 boolean equals(Object obj) 
         " 比较此对象与指定对象。" 
 float floatValue() 
         " 以 float 类型返回该 Integer 的值。" 
static Integer getInteger(String nm) 
          "确定具有指定名称的系统属性的整数值。" 
static Integer getInteger(String nm, int val) 
          "确定具有指定名称的系统属性的整数值。" 
static Integer getInteger(String nm, Integer val) 
          "返回具有指定名称的系统属性的整数值。" 
 int hashCode() 
          "返回此 Integer 的哈希码。" 
static int highestOneBit(int i) 
          "返回具有至多单个 1 位的 int 值，在指定的 int 值中最高位（最左边）的 1 位的位置。 "
 int intValue() 
          "以 int 类型返回该 Integer 的值。" 
 long longValue() 
          "以 long 类型返回该 Integer 的值。" 
static int lowestOneBit(int i) 
         " 返回具有至多单个 1 位的 int 值，在指定的 int 值中最低位（最右边）的 1 位的位置。" 
static int numberOfLeadingZeros(int i) 
         " 在指定 int 值的二进制补码表示形式中最高位（最左边）的 1 位之前，返回零位的数量。" 
static int numberOfTrailingZeros(int i) 
         " 返回指定的 int 值的二进制补码表示形式中最低（“最右边”）的为 1 的位后面的零位个数。" 
static int parseInt(String s) 
         " 将字符串参数作为有符号的十进制整数进行解析。" 
static int parseInt(String s, int radix) 
          "使用第二个参数指定的基数，将字符串参数解析为有符号的整数。 "
static int reverse(int i) 
          "返回通过反转指定 int 值的二进制补码表示形式中位的顺序而获得的值。 "
static int reverseBytes(int i) 
          "返回通过反转指定 int 值的二进制补码表示形式中字节的顺序而获得的值。" 
static int rotateLeft(int i, int distance) 
          "返回根据指定的位数循环左移指定的 int 值的二进制补码表示形式而得到的值。" 
static int rotateRight(int i, int distance) 
          "返回根据指定的位数循环右移指定的 int 值的二进制补码表示形式而得到的值。 "
 short shortValue() 
         " 以 short 类型返回该 Integer 的值。 "
static int signum(int i) 
          "返回指定 int 值的符号函数。 "
static String toBinaryString(int i) 
         " 以二进制（基数 2）无符号整数形式返回一个整数参数的字符串表示形式。" 
static String toHexString(int i) 
          "以十六进制（基数 16）无符号整数形式返回一个整数参数的字符串表示形式。 "
static String toOctalString(int i) 
          "以八进制（基数 8）无符号整数形式返回一个整数参数的字符串表示形式。" 
 String toString() 
          "返回一个表示该 Integer 值的 String 对象。 "
static String toString(int i) 
         " 返回一个表示指定整数的 String 对象。 "
static String toString(int i, int radix) 
          "返回用第二个参数指定基数表示的第一个参数的字符串表示形式。" 
static Integer valueOf(int i) 
         " 返回一个表示指定的 int 值的 Integer 实例。" 
static Integer valueOf(String s) 
          "返回保存指定的 String 的值的 Integer 对象。 "
static Integer valueOf(String s, int radix) 
         " 返回一个 Integer 对象，该对象中保存了用第二个参数提供的基数进行解析时从指定的 String 中提取            的值。 "

public class PrintStream
{
  public PrintStream printf(String fmt,Object...args)
  {
    return format(fmt,args);
  }
}
/*
Object...args表明这个方法可以接受任意数量的对象
*/

public enum Size
{
  SMALL("S"),MEDIUM("M"),LARGE("L"),EXTRA_LARGE("XL");
  
  private String abbreviatation;
  
  private Size(String abbreviation)
  {
    this.abbreviation=abbreviation;
  }
  public String getAbbreviation(){
    return abbreviation;
  }
}

Size.SMALL.toString()//返回字符串“SMALL”
Size s=Enum.valueOf(Size.class,"SMALL")//将s设置为Size.SMALL

方法摘要 
protected  Object clone() 
          "抛出 CloneNotSupportedException。 "
 int compareTo(E o) 
         " 比较此枚举与指定对象的顺序。" 
 boolean equals(Object other) 
          "当指定对象等于此枚举常量时，返回 true。 "
protected  void finalize() 
          "枚举类不能有 finalize 方法。" 
 Class<E> getDeclaringClass() 
          "返回与此枚举常量的枚举类型相对应的 Class 对象。 "
 int hashCode() 
         " 返回枚举常量的哈希码。" 
 String name() 
          "返回此枚举常量的名称，在其枚举声明中对其进行声明。 "
 int ordinal() 
          "返回枚举常量的序数（它在枚举声明中的位置，其中初始常量序数为零）。" 
 String toString() 
         " 返回枚举常量的名称，它包含在声明中。" 
static <T extends Enum<T>> T 
 valueOf(Class<T> enumType, String name) 
         " 返回带指定名称的指定枚举类型的枚举常量。" 

package reflection;
 
import charactor.Hero;
 
public class TestReflection {
 
    public static void main(String[] args) {
            String className = "charactor.Hero";
            try {
                Class pClass1=Class.forName(className);
                Class pClass2=Hero.class;
                Class pClass3=new Hero().getClass();
                System.out.println(pClass1==pClass2);
                System.out.println(pClass1==pClass3);
            } catch (ClassNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
    }
}

static String copyright;
static {
    System.out.println("初始化 copyright");
    copyright = "版权由Riot Games公司所有";
}

package charactor;
 
public class Hero {
    public String name;
    public float hp;
    public int damage;
    public int id;
 
    static String copyright;
 
    static {
        System.out.println("初始化 copyright");
        copyright = "版权由Riot Games公司所有";
    }
 
}

package reflection;
 
import charactor.Hero;
 
public class TestReflection {
 
    public static void main(String[] args) {
            String className = "charactor.Hero";
            try {
                Class pClass1=Class.forName(className);
                Class pClass2=Hero.class;
                Class pClass3=new Hero().getClass();
            } catch (ClassNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
    }
}

package reflection;
import java.lang.reflect.Constructor;
import charactor.Hero;
public class TestReflection {
  
    public static void main(String[] args) {
        //传统的使用new的方式创建对象
        Hero h1 =new Hero();
        h1.name = "teemo";
        System.out.println(h1);
          
        try {
            //使用反射的方式创建对象
            String className = "charactor.Hero";
            //类对象
            Class pClass=Class.forName(className);
            //构造器
            Constructor c= pClass.getConstructor();
            //通过构造器实例化
            Hero h2= (Hero) c.newInstance();
            h2.name="gareen";
            System.out.println(h2);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

package charactor;
  
public class APHero extends Hero {
  
    public void magicAttack() {
        System.out.println("进行魔法攻击");
    }
  
}

package charactor;
  
public class ADHero extends Hero {
  
    public void physicAttack() {
        System.out.println("进行物理攻击");
    }
  
}

package charactor;
 
public class Hero {
    public String name;
    public float hp;
    public int damage;
    public int id;
     
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Hero(){
         
    }
    public Hero(String string) {
        name =string;
    }
 
    @Override
    public String toString() {
        return "Hero [name=" + name + "]";
    }
    public boolean isDead() {
        // TODO Auto-generated method stub
        return false;
    }
    public void attackHero(Hero h2) {
        System.out.println(this.name+ " 正在攻击 " + h2.getName());
    }
 
}

package reflection;
 
import java.lang.reflect.Field;
 
import charactor.Hero;
  
public class TestReflection {
  
    public static void main(String[] args) {
            Hero h =new Hero();
            //使用传统方式修改name的值为garen
            h.name = "garen";
            try {
                //获取类Hero的名字叫做name的字段
                Field f1= h.getClass().getDeclaredField("name");
                //修改这个字段的值
                f1.set(h, "teemo");
                //打印被修改后的值
                System.out.println(h.name);
                 
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
    }
}

package charactor;
 
public class Hero {
    public String name;
    public float hp;
    public int damage;
    public int id;
     
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Hero(){
         
    }
    public Hero(String string) {
        name =string;
    }
 
    @Override
    public String toString() {
        return "Hero [name=" + name + "]";
    }
    public boolean isDead() {
        // TODO Auto-generated method stub
        return false;
    }
    public void attackHero(Hero h2) {
        // TODO Auto-generated method stub
         
    }
 
}

package reflection;
 
import java.lang.reflect.Method;
 
import charactor.Hero;
 
public class TestReflection {
 
    public static void main(String[] args) {
        Hero h = new Hero();
 
        try {
            // 获取这个名字叫做setName，参数类型是String的方法
            Method m = h.getClass().getMethod("setName", String.class);
            // 对h对象，调用这个方法
            m.invoke(h, "盖伦");
            // 使用传统的方式，调用getName方法
            System.out.println(h.getName());
 
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
 
    }
}