8：String类

String类

String类的特点：
字符串对象一旦被初始化就不会被改变。

字符串是最常用的类型之一，所以为了使用方便java就给封装成了对象方便使用


 public static void stringDemo2() { 

 String s = "abc";//创建一个字符串对象在常量池中。   

  String s1 = new String("abc");//创建两个对象一个new一个字符串对象在堆内存和常量池中。 

System.out.println(s==s1);//false

System.out.println(s.equals(s1));

string类中的equals复写Object中的equals建立了string类自己的判断字符串对象是否相同的依据。

其实就是比较字符串内容。

演示字符串定义的第一种方式，并明确字符串常量池的特点.

池中没有就建立，池中有，直接用。


 private static void stringDemo1() {

  String s = "abc";//"abc"存储在字符串常量池中。

//	 s = "nba";

  String s1 = "abc";

  System.out.println(s==s1);//true

//	 System.out.println("s="+s);

/输出nab，s和s1是俩个字符串对象，s一开始指向了abc，又指向了nba，abc不变说的是这个意思
}

常量池：

因为String类型一旦被初始化是不能被改变的，所以存放在常量池，存放在常量池中还有个很重要的原因：String s1 = “abs”；String s2=“abs”，这时s2并没有新建立一个对象，而是指向了s1这个对象。也就是说每当创建一个字符串时，并不是直接创建而是先到常量池中区找需要创建的对象是否存在，如果存在就不会再创建了。常量池中的元素是不会重复的，这也就是所谓的享元模式，例如当已经存在abs，这时需要创建ahk，这时常量池中只会增加两个字符h和k，然后在从常量池中抽出ahk对象。

特点：

1、String是一种特殊的数据类型，可创建对象。

2、通过String创建的对象分别可存在于常量池和堆内存中

3、String是一个final的类型，即不可被继承修改，一经初始化就终生不可改变。（要改变也是改变的引用）

4、常量池中的数据可共享，即两个引用变量可指向同一个字符串池中的字符串

5、Java中的任何对象都可写成字符串的形式。

6、既然String是对象，那就不得不说说null和“”的区别了。null是String对象指向为空，就是没有指向。而“”代表的是String对象指向的是一个空的字符串。

8：String类

匿名对象

匿名对象就是表示没有名字的对象，那么什么叫对象的名字了？

8：String类

一个字符串就是一个string的匿名对象

8：String类

String类的构造器

将字节数组或者字符数组转成字符串可以通过String类的构造函数完成。


 private static void stringConstructorDemo2() { 

  char[] arr = {'w','a','p','q','x'};//字符串转换成数组

  String s = new String(arr,1,3);//字符的一部分转换成数组，从1角标取

  System.out.println("s="+s); 输出s=apq

 }


 public static void stringConstructorDemo() {

  String s = new String();

//等效于String s = ""内容一样，地址不一样，都是指向空字符串; 但不等效String s = null;

一般用String s = ""，就行了，能被共享,当需要用构造器传数据，需要用new，

 byte[] arr = {97,66,67,68}; 

String s1 = new String(arr); //将数组变为字符，输出了abcd,编码转成了字节存储起来

  System.out.println("s1="+s1);

   }

String类的方法（常见功能）

按照面向对象的思想对字符串进行功能分类

字符串常见的操作方法：（String str = "hello java"）

1、获取。

1.1 字符串中的包含的字符数，也就是字符串的长度。

int length():获取长度。str.length()//结果为10

1.2 根据位置获取位置上某个字符。

char charAt(int index)://charAt(1)，结果是e

1.3 根据字符获取该字符在字符串中位置。//indexOf(’l‘)结果是2

int indexOf(int ch):返回的是ch在字符串中第一次出现的位置。

int indexOf(int ch, int fromIndex) :从fromIndex指定位置开始，获取ch在字符串中出现的位置。

int indexOf(String str):返回的是str在字符串中第一次出现的位置。

int indexOf(String str, int fromIndex) :从fromIndex指定位置开始，获取str在字符串中出现的位置。

int lastIndexOf(int ch) ：从后往前找，但是字符串中的角标是没有变的。

System.out.println("substring:"+s.substring(2,4));//cd

2、判断。
2.1 字符串中是否包含某一个子串。
boolean contains(str):
特殊之处：indexOf(str):可以索引str第一次出现位置，如果返回-1.表示该str不在字符串中存在。所以，也可以用于对指定判断是否包含。if(str.indexOf("aa")!=-1)
而且该方法即可以判断，有可以获取出现的位置。
2.2 字符中是否有内容。
boolean isEmpty(): 原理就是判断长度是否为0.
2.3 字符串是否是以指定内容开头。
boolean startsWith(str);
2.4 字符串是否是以指定内容结尾。
boolean endsWith(str);
2.5 判断字符串内容是否相同。复写了Object类中的equals方法。
boolean equals(str);
2.6 判断内容是否相同，并忽略大小写。
boolean equalsIgnoreCase();

3、转换。

3.1 将字符数组转成字符串。
构造函数：String(char[])
String(char[],offset,count):将字符数组中的一部分转成字符串。
静态方法：
static String copyValueOf(char[]);
static String copyValueOf(char[] data, int offset, int count)
static String valueOf(char[]):
3.2 将字符串转成字符数组。**
char[] toCharArray():
3.3 将字节数组转成字符串。
String(byte[])
String(byte[],offset,count):将字节数组中的一部分转成字符串。
3.4 将字符串转成字节数组。
byte[] getBytes():
3.5 将基本数据类型转成字符串。
static String valueOf(int)
static String valueOf(double)
//3+"";//String.valueOf(3);
特殊：字符串和字节数组在转换过程中，是可以指定编码表的。
4，替换
String replace(oldchar,newchar);
5，切割
String[] split(regex);
6，子串。获取字符串中的一部分。
String substring(begin);
String substring(begin,end);
7，转换，去除空格，比较。
7.1 将字符串转成大写或则小写。
String toUpperCase();
String toLowerCase();
7.2 将字符串两端的多个空格去除。
String trim();
7.3 对两个字符串进行自然顺序的比较。
int compareTo(string);//大于返回正数，等于返回0，小于返回负数，且值为ASSII值之差。


 private static void stringMethodDemo_4() {
 
 System.out.println("abc".compareTo("aqz"));
 }
  stringMethodDemo_4();
 }


public class StringObjectDemo {
	public static void main(String[] args) {
		// String s1 = "abc";
		// String s2 = "abc";
		// intern():对字符串池进行操作的
		String s1 = new String("abc");
		String s2 = s1.intern();
		System.out.println(s1 == s2); // false
	}
}


public class StringDemo {  
    public static void main(String[] args) {  
        String str = "asdfghjaszxsa.java";  
        method_get(str);  
        print("------------------------------------------");  
        method_is(str);  
        print("------------------------------------------");  
        method_transform(str);  
        print("------------------------------------------");  
        method_replace(str);  
        print("------------------------------------------");  
        method_split(str);  
        print("------------------------------------------");  
        method_sub(str);  
        print("------------------------------------------");  
        method_change();  
    }  
  
    /*  
     * String获取方法 凡是获取的字符或者是字符串不存在，就返回-1  
     */  
    private static void method_get(String str) {  
        // 获取字符串的长度  
        int length = str.length();  
        print("length: " + length);  
  
        // 根据位置获取位置上的某个字符  
        char ch = str.charAt(1);  
        print("ch: " + ch);  
  
        // 根据字符获取该字符在字符串中的位置  
        int index = str.indexOf("index: " + 'a');// 获取该字符第一次出现的位置  
        print("index: " + index);  
  
        // int indexOf(int ch, int fromIndex) :从fromIndex指定位置开始，获取ch在字符串中出现的位置。  
        int indexf = str.indexOf('a', 2);  
        print("indexf: " + indexf);  
  
        // int indexOf(String str):返回的是str在字符串中第一次出现的位置。  
        int indexs = str.indexOf("as");  
        print("indexs: " + indexs);  
  
        // int indexOf(String str, int fromIndex)  
        // :从fromIndex指定位置开始，获取str在字符串中出现的位置。  
        int indexsf = str.indexOf("as", 3);  
        print("indexsf: " + indexsf);  
  
        // int lastIndexOf(int ch)  
        int indexlast = str.lastIndexOf('a');  
        print("indexlast: " + indexlast);  
    }  
  
    /*  
     * String中的判断  
     */  
    private static void method_is(String str) {  
        // 字符串中是否包含某一个子串  
        /*  
         * 特殊之处：indexOf(str):可以索引str第一次出现位置，如果返回-1.表示该str不在字符串中存在。  
         * 所以，也可以用于对指定判断是否包含。 if(str.indexOf("aa")!=-1) 而且该方法即可以判断，有可以获取出现的位置。  
         */  
        boolean iscon = str.contains("asd");  
        print("iscon: " + iscon);  
  
        // 字符中是否有内容。boolean isEmpty(): 原理就是判断长度是否为0.  
        boolean isemp = str.isEmpty();  
        print("isemp: " + isemp);  
  
        // 字符串是否是以指定内容开头。boolean startsWith(str);  
        boolean start = str.startsWith("asd");  
        boolean startoffset = str.startsWith("sd", 1);  
        print("start: " + start);  
        print("startoffset: " + startoffset);  
  
        // 字符串是否是以指定内容结尾。boolean endsWith(str);  
        boolean end = str.endsWith(".java");  
        print("end: " + end);  
  
        // 判断字符串内容是否相同。复写了Object类中的equals方法。boolean equals(str);  
        boolean equal = str.equals("asdfghjaszxsa.java");  
        print("equal: " + equal);  
  
        // 判断内容是否相同，并忽略大小写。boolean equalsIgnoreCase();  
        boolean equ = "AASD".equalsIgnoreCase("Aasd");  
        print("equ: " + equ);  
    }  
  
    /*  
     * 转换  
     */  
    private static void method_transform(String str) {  
        char[] chs = { 'a', 's', 'd', 'f', 'g' };  
        byte[] bts = { 'a', 's', 'd', 'f', 'g' };  
  
        // 将字符数组转成字符串  
        String trChStr = new String(chs);  
        String trChStrO = new String(chs, 1, 3);  
        print("trChStr: " + trChStr + "....trChStrO: " + trChStrO);  
        String copyvalueof = String.copyValueOf(chs);  
        print("copyvalueof: " + copyvalueof);  
  
        // 将字符串转成字符数组****  
        char[] tochar = str.toCharArray();  
        for (int x = 0; x < tochar.length; x++) {  
            print("char[" + x + "] = " + tochar[x]);  
        }  
  
        // 将字节数组转成字符串。  
        String trBtStr = new String(bts);  
        String trBtStrO = new String(bts, 1, 3);  
        print("trBtStr: " + trBtStr + "....trBtStrO: " + trBtStrO);  
  
        // 将字符串转成字节数组。byte[] getBytes():  
        // 特殊：字符串和字节数组在转换过程中，是可以指定编码表的。  
        byte[] getBts = str.getBytes();  
        for (int x = 0; x < getBts.length; x++) {  
            print("byte[" + x + "] = " + getBts[x]);  
        }  
  
        // 将基本数据类型转成字符串。static String valueOf(数据类型)  
        // 3+"";//String.valueOf(3);  
        String num = String.valueOf(2);  
        print("num: " + num);  
    }  
  
    /*  
     * 替换  
     */  
    private static void method_replace(String str) {  
        // 如果要替换的字符不存在，返回的还是原串。  
        String newStr = str.replace('a', 'm');// 替换掉所有的该字符  
        print(str);  
        print(newStr);  
  
        String newSt = str.replace("asd", "qqq");  
        print(str);  
        print(newSt);  
  
    }  
  
    /*  
     * 切割  
     */  
    private static void method_split(String str) {  
        // String[] split(regex);  
        String[] strs = str.split("s");  
        for (int x = 0; x < strs.length; x++) {  
            print("String[" + x + "] = " + strs[x]);  
        }  
    }  
  
    /*  
     * 获取字符串中的一部分  
     */  
    private static void method_sub(String str) {  
        print(str.substring(2));// 从指定位置开始到结尾。如果角标不存在，会出现字符串角标越界异常。  
        print(str.substring(2, 4));// 包含头，不包含尾。s.substring(0,s.length());  
    }  
  
    /*  
     * 转换，去除空格，比较。  
     */  
    private static void method_change() {  
        String s = "        Hello Java       ";  
        print(s.toLowerCase());// 转小写  
        print(s.toUpperCase());// 转大写  
        print(s.trim());// 去空格  
  
        // 对两个字符串进行自然顺序的比较  
        String s1 = "aaa";  
        String s2 = "aaa";  
        print(s1.compareTo(s2));// 大于返回正数，小于返回负数，相等返回0  
    }  
  
    private static void print(Object obj) {  
        System.out.println(obj);  
    }

System.out.println("abc".concat("kk"));连接字符串，没什么用，直接连就行

System.out.println("abc"+"kk");

System.out.println(String.valueOf(4)+1)；//41将基本数据类型变为字符串，再连接

System.out.println(""+4+1);和上一样

练习

* 1，给定一个字符串数组。按照字典顺序进行从小到大的排序。

* {"nba","abc","cba","zz","qq","haha"}

* 思路：

* 1,对数组排序。可以用选择，冒泡都行。

* 3,问题：以前排的是整数，比较用的比较运算符，可是现在是字符串对象。

* 字符串对象怎么比较呢？对象中提供了用于字符串对象比较的功能。


public class StringTest_1 {
	public static void main(String[] args) {
		String[] arr = { "nba", "abc", "cba", "zz", "qq", "haha" };
		printArray(arr); // 原来的
		sortString(arr);
		printArray(arr); // 比较后的
	}

	public static void sortString(String[] arr) {
		for (int i = 0; i < arr.length - 1; i++) {
			for (int j = i + 1; j < arr.length; j++) {
				if (arr[i].compareTo(arr[j]) > 0)// 字符串比较用compareTo方法
					swap(arr, i, j);
			}
		}
	}

	private static void swap(String[] arr, int i, int j) {
		String temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}

	public static void printArray(String[] arr) {
		System.out.print("[");
		for (int i = 0; i < arr.length; i++) {
			if (i != arr.length - 1)
				System.out.print(arr[i] + ", ");
			else
				System.out.println(arr[i] + "]");
		}
	}
}

2，一个子串在整串中出现的次数。

* "nbaernbatynbauinbaopnba"

* 思路：

* 1，要找的子串是否存在，如果存在获取其出现的位置。这个可以使用indexOf完成。

* 2，如果找到了，那么就记录出现的位置并在剩余的字符串中继续查找该子串，

* 而剩余字符串的起始位是出现位置+子串的长度.

* 3,以此类推，通过循环完成查找，如果找不到就是-1，并对每次找到用计数器记录。


public class StringTest_2 {

	public static void main(String[] args) {
		String str = "nbaernbatnbaynbauinbaopnba";
		String key = "nba";
		int count = getKeyStringCount_2(str, key);
		System.out.println("count=" + count);
	}

	public static int getKeyStringCount_2(String str, String key) {
		int count = 0;
		int index = 0;
		while ((index = str.indexOf(key, index)) != -1) {
			index = index + key.length();
			count++;
		}
		return count;
	}

	/**
	 * 获取子串在整串中出现的次数。
	 */
	public static int getKeyStringCount(String str, String key) {
		// 1,定义计数器。
		int count = 0;
		// 2，定义变量记录key出现的位置。
		int index = 0;
		while ((index = str.indexOf(key)) != -1) {
			str = str.substring(index + key.length());//这个前面的str别不写
			count++;
		}
		return count;
	}
}

* 3，两个字符串中最大相同的子串。

* "qwerabcdtyuiop"

* "xcabcdvbn"

* 思路：

* 1，既然取得是最大子串，先看短的那个字符串是否在长的那个字符串中。

* 如果存在，短的那个字符串就是最大子串。

* 2，如果不是呢，那么就将短的那个子串进行长度递减的方式去子串，去长串中判断是否存在。

* 如果存在就已找到，就不用在找了。


public class StringTest_3 {
	public static void main(String[] args) {
		String s1 = "qwerabcdtyuiop";
		String s2 = "xcabcdvbn";
		String s = getMaxSubstring(s2, s1);
		System.out.println("s=" + s);
	}

	/**
	 * 获取最大子串
	 * 
	 * @param s1
	 * @param s2
	 * @return
	 */
	public static String getMaxSubstring(String s1, String s2) {
		String max = null, min = null;
		max = (s1.length() > s2.length()) ? s1 : s2;
		min = max.equals(s1) ? s2 : s1;
		System.out.println("max=" + max);
		System.out.println("min=" + min);
		for (int i = 0; i < min.length(); i++) {
			for (int a = 0, b = min.length() - i; b != min.length() + 1; a++, b++) {
				String sub = min.substring(a, b);
				// System.out.println(sub);
				if (max.contains(sub))
					return sub;
			}
		}
		return null;
	}
}

* 4，模拟一个trim功能一致的方法。去除字符串两端的空白

* 思路：

* 1，定义两个变量。

* 一个变量作为从头开始判断字符串空格的角标。不断++。

* 一个变量作为从尾开始判断字符串空格的角标。不断--。

* 2,判断到不是空格为止，取头尾之间的字符串即可。


public class StringTest_4 {

	public static void main(String[] args) {
		String s = "    ab   c     ";
		s = myTrim(s);
		System.out.println("-" + s + "-");
	}

	public static String myTrim(String s) {
		int start = 0, end = s.length() - 1;
		while (start <= end && s.charAt(start) == ' ') {
			start++;
		}
		while (start <= end && s.charAt(end) == ' ') {
			end--;
		}
		return s.substring(start, end + 1);
	}
}

练习五：将字符串反转。


 /*  
 思路：  
 1，将字符串变成数组。  
 2，对数组反转。  
 3，将数组变成字符串。  
 */  
  
public class ReverseString {  
    public static void main(String[] args) {  
        String str = "shag klh";  
        String out = reverseString(str);  
        System.out.println(out);  
    }  
  
    /*  
     * 将字符串反转  
     */  
    private static String reverseString(String str) {  
        // 将字符串变成数组  
        char[] chs = str.toCharArray();  
  
        // 将数组反正，也就是收尾调换  
        reverseArray(chs);  
          
        return new String(chs);  
    }  
  
    private static void reverseArray(char[] chs) {  
        char temp;  
        for (int start = 0, end = chs.length - 1; start < end; start++, end--) {  
            temp = chs[start];  
            chs[start] = chs[end];  
            chs[end] = temp;  
        }  
    }

StringBuffer

* StringBuffer:就是字符串缓冲区。

* 用于存储数据的容器。

* 特点：

* 1，长度的可变的。

* 2，可以存储不同类型数据。

* 3，最终要通过toString方法变成字符串进行使用。

* 4，可以对字符串进行修改。

Stringbuffer类：可以被修改的字符序列

8：String类

* 既然是一个容器对象。应该具备什么功能呢？

1、存储。
StringBuffer append():将指定数据作为参数添加到已有数据结尾处。不支持byte和char，需要对其进行转换才能操作。
StringBuffer insert(index,数据):可以将数据插入到指定index位置。
2、删除。
StringBuffer delete(start,end):删除缓冲区中的数据，包含start，不包含end。
StringBuffer deleteCharAt(index):删除指定位置的字符。
3、获取。
char charAt(int index)
int indexOf(String str)
int lastIndexOf(String str)
int length()
String substring(int start, int end)
4、修改。
StringBuffer replace(start,end,string);
void setCharAt(int index, char ch) ;
5、反转。
StringBuffer reverse();
6、将缓冲区中指定数据存储到指定字符数组中。
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)//第一个参数是说StringBuffer 从哪开始取值，第二个就是在哪结束啦，第三个参数是插入到哪个数据，第四个是说从数组中的哪个索引开始插入。

* 增删改查 C(create)U(update)R(read)D(delete)


public class StringBufferDemo {
	public static void main(String[] args) {
		bufferMethodDemo_2();
	}

	private static void bufferMethodDemo_2() {
		StringBuffer sb = new StringBuffer("abce");
		// sb.delete(1, 3);//ae
		// 清空缓冲区
		// sb.delete(0,sb.length());
		// sb = new StringBuffer();
		// sb.replace(1, 3, "nba");
		// sb.setCharAt(2, 'q');
		// sb.setLength(10);
		// System.out.println("sb:"+sb);
		// System.out.println("len:"+sb.length());
		System.out.println(sb.reverse());
	}

	private static void bufferMethodDemo_1() {
		StringBuffer sb = new StringBuffer("abce");
		// sb.append("xixi");
		sb.insert(2, "qq");
		System.out.println(sb.toString());
	}

	public static void bufferMethodDemo() {
		// 创建缓冲区对象。
		StringBuffer sb = new StringBuffer();

		sb.append(4).append(false);// .append("haha");输出4falsehahh，连起来了

		sb.insert(1, "haha")；//4hahhfalse

		// sb.append(true);//4hahhfalsetru，一个一个append和.append效果一样
		System.out.println(sb);
	}
}

StringBuilder

* jdk1.5以后出现了功能和StringBuffer一模一样的对象。就是StringBuilder

* 不同的是：

* StringBuffer是线程同步的。通常用于多线程。

* StringBuilder是线程不同步的。通常用于单线程。它的出现提高效率。

* jdk升级：

* 1，简化书写。

* 2，提高效率。

* 3，增加安全性。

eg：


public class StringBuilderTest {

	public static void main(String[] args) {

		int[] arr = { 3, 1, 5, 3, 8 };

		String s = arrayToString_2(arr);

		System.out.println(s);

	}

	public static String arrayToString_2(int[] arr) {

		StringBuilder sb = new StringBuilder();

		sb.append("[");

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

			if (i != arr.length - 1)

				sb.append(arr[i] + ", ");
			else

				sb.append(arr[i] + "]");
		}

		return sb.toString();
	}

	/**
	 * 
	 * 将一个int数组变成字符串。
	 */
	public static String arrayToString(int[] arr) {

		String str = "[";

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

			if (i != arr.length - 1)

				str += arr[i] + ", ";
			else
				str += arr[i] + "]";
		}
		return str;
	}

}


public class StringBuilderTest {

	public static void main(String[] args) {

		StringBuilder s1 = new StringBuilder("hello");

		StringBuilder s2 = new StringBuilder("java");

		show(s1, s2);

		System.out.println(s1 + "......." + s2);

	}
	private static void show(StringBuilder s1, StringBuilder s2) {

		s1.append(s2);

		s1 = s2;
//输出hellojava.......java


	}

}

基本数据类型对象包装类

* 为了方便操作基本数据类型值，将其封装成了对象，在对象中定义了属性和行为丰富了该数据的操作。

* 用于描述该对象的类就称为基本数据类型对象包装类。

* byte Byte

* short Short

* int Integer

* long Long

* float Float

* double Double

* char Character

* boolean Boolean

* 该包装对象主要用基本类型和字符串之间的转换。

基本类型--->字符串

基本类型数值+""
用String类中的静态方法valueOf(基本类型数值);
用Integer的静态方法valueO(基本类型数值);

字符串--->基本类型

使用包装类中的静态方法 xxx parseXxx("xxx类型的字符串");*****

* int parseInt("intstring");

* long parseLong("longstring");

* boolean parseBoolean("booleanstring");

* 只有Character没有parse方法

2.如果字符串被Integer进行对象的封装。

* 可使用另一个非静态的方法，intValue();

* 将一个Integer对象转成基本数据类型值。


System.out.println(Integer.MAX_VALUE);

System.out.println(Integer.toBinaryString(-6)); 

int num = 4;

Integer i = new Integer(5);

int x = Integer.parseInt("123");

System.out.println(Integer.parseInt("123")+1); 

Integer i = new Integer("123");
);
  System.out.println(a==b);//flase
  System.out.println(a.equals(b));//ture
//	 System.out.println(3>3);
  System.out.println(a.compareTo(b));//0,内容相同，地址不同

* 整数具备不同的进制体现。

* 十进制-->其他进制。

* toBinaryString

* toOctalString

* toHexString

* 其他进制-->十进制。

* parseInt("string",radix)

十进制-->其他进制。


  System.out.println(Integer.toBinaryString(60)); 

  System.out.println(Integer.toOctalString(60));

  System.out.println(Integer.toHexString(60));

//	 System.out.println(Integer.toString(60,16));

其他进制-->十进制。



class IntegerDemo   
{  
    public static void sop(String str)  
    {  
        System.out.println(str);  
    }  
      
    public static void main(String[] args)   
    {  
        //整数类型的最大值。  
        //sop("int max :"+Integer.MAX_VALUE);  
  
//      将一个字符串转成整数。  
  
        int num = Integer.parseInt("123");//必须传入数字格式的字符串。  
        //long x = Long.parseLong("123");  
  
//      sop("num="+(num+4));  
  
//      sop(Integer.toBinaryString(-6));  
//      sop(Integer.toHexString(60));  
  
        int x = Integer.parseInt("3c",16);  //后面传入前面是什么进制的
  
        sop("x="+x);

自动装箱拆箱


class IntegerDemo1   
{  
    public static void main(String[] args)   
    {  
          
//      Integer x = new Integer(4);  
  
        Integer x = 4;//自动装箱。//new Integer(4)  
  
        x = x/* x.intValue() */ + 2;//x+2:x 进行自动拆箱。变成成了int类型。和2进行加法运算  
                    //再将和进行装箱赋给x  
  
        Integer m = 128;  
        Integer n = 128;  
  
        sop("m==n:"+(m==n));//结果为false  
  
        Integer a = 127;  
        Integer b = 127;  
  
        sop("a==b:"+(a==b));//结果为true。因为a和b指向了同一个Integer对象 
          //因为当数值在byte范围内容，对于新特性，如果该数值已经存在，则不会在开辟新的空间  
    }  
  
    public static void method()  
    {  
        Integer x = new Integer("123");  
  
        Integer y = new Integer(123);  
  
        sop("x==y:"+(x==y));  
        sop("x.equals(y):"+x.equals(y));  
    }

来自为知笔记(Wiz)

相关文章