Java中的基本数据类型装箱拆箱、数据类型缓冲池、增强for循环


public static void main(String[] args) {
	/** jdk1.5之前手动装拆箱 */
	List list = new ArrayList();
	int i = 0;			// 基本数据类型
	Integer it = new Integer(i);	// 复杂数据类型。1.手动装箱
	list.add(it);
	Object object = list.get(0);
	Integer itg = (Integer) object;	// 2.强转
	int ii = itg.intValue();	// 3.手动拆箱
	
	/** jdk1.5之后，自动装拆箱 */
	list = new ArrayList();
	int j = 0;			// 1.自动装箱
	list.add(j);
	int k = (Integer) list.get(0);	// 2.自动拆箱。Integer -> int
	
	/* 自动拆箱 */
	Integer itg2 = new Integer(90);
	itg2 ++;
	System.out.println(itg2);	// 91
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

public static void main(String[] args) {

/** jdk1.5之前手动装拆箱 */

List list = new ArrayList();

int i = 0; // 基本数据类型

Integer it = new Integer(i); // 复杂数据类型。1.手动装箱

list.add(it);

Object object = list.get(0);

Integer itg = (Integer) object; // 2.强转

int ii = itg.intValue(); // 3.手动拆箱

/** jdk1.5之后，自动装拆箱 */

list = new ArrayList();

int j = 0; // 1.自动装箱

list.add(j);

int k = (Integer) list.get(0); // 2.自动拆箱。Integer -> int

/* 自动拆箱 */

Integer itg2 = new Integer(90);

itg2 ++;

System.out.println(itg2); // 91

}


public static void main(String[] args) {
	/*
	 * ==，比较的是一个对象在内存中的地址值
	 * equals同样使用==号进行内存地址的比较。但是许多java类中都重写了这个方法，而不仅仅判断内存地址
	 */
	
	/*
	 * 虚拟机为提高效率，为
	 * Integer valueOf(int i)、Byte valueOf(byte b)、Short valueOf(short s)、Long valueOf(long l)、
	 * Character valueOf(char c)都是用到了缓冲机制，并且缓冲的范围都是-128~127。
	 * 但对于包装类Float,Double,Boolean 并没有提供相应的缓冲机制。
	 */
	Integer i1 = 127;
	Integer i2 = 127;	// 来自缓冲池
	System.out.println((i1 == i2) + "," + i1.equals(i2));		// true-内存地址,true-字符串值
	
	// 缓冲池的大小由数据类型决定。
	Integer it1 = 128;	// 缓冲池中放不下
	Integer it2 = 128;	// Integer it2 = new Integer(128);
	System.out.println((it1 == it2) + "," + it1.equals(it2));	// false,true
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

public static void main(String[] args) {

/*

* ==，比较的是一个对象在内存中的地址值

* equals同样使用==号进行内存地址的比较。但是许多java类中都重写了这个方法，而不仅仅判断内存地址

*/

/*

* 虚拟机为提高效率，为

* Integer valueOf(int i)、Byte valueOf(byte b)、Short valueOf(short s)、Long valueOf(long l)、

* Character valueOf(char c)都是用到了缓冲机制，并且缓冲的范围都是-128~127。

* 但对于包装类Float,Double,Boolean 并没有提供相应的缓冲机制。

*/

Integer i1 = 127;

Integer i2 = 127; // 来自缓冲池

System.out.println((i1 == i2) + "," + i1.equals(i2)); // true-内存地址,true-字符串值

// 缓冲池的大小由数据类型决定。

Integer it1 = 128; // 缓冲池中放不下

Integer it2 = 128; // Integer it2 = new Integer(128);

System.out.println((it1 == it2) + "," + it1.equals(it2)); // false,true

}


public static void main(String[] args) {
	/**------------------引用与新建--------------------------*/
	String s1 = "abc";	/** 如果String池中没有，则在String池创建。栈内存 */
	String s2 = "abc";	/** 如果有了，直接引用  */
	System.out.println(s1 == s2);	// true
	
	String s3 = new String();
	s3 = "abc";			/** 如果有了，直接引用  */
	System.out.println(s1 == s3);	// true
	System.out.println(s2 == s3);	// true
	
	String s4 = new String("abc"); /** 通过new得到的，都是开辟新内存。堆内存  */
	System.out.println(s1 == s4);	// false
	System.out.println(s2 == s4);	// false
	System.out.println(s3 == s4);	// false
	
	s4 = "abc";			/** 如果有了，直接引用  */
	System.out.println(s1 == s4);	// true

	/**------------------编译与运行--------------------------*/
	String str1 = "a" + "b" + "c" + "d";	// 编译阶段，这里会被合并为“abcd”
	String str2 = "abcd";
	System.out.println(str1 == str2);	// true

	/**------------------“自动装箱”--------------------------*/
	String string1 = "ab";		// 保存进String池
	String string2 = "cdef";	// 保存进String池
	/** 下面的执行为：
	 * StringBuilder sb = new StringBuilder(string1).append(string2); 
	 * String string3 = sb.toString(); */
	String string3 = string1 + string2;		// 通过方法返回的对象，在堆内存
	System.out.println(string3 == "abcdef");	// false
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

public static void main(String[] args) {

/**------------------引用与新建--------------------------*/

String s1 = "abc"; /** 如果String池中没有，则在String池创建。栈内存 */

String s2 = "abc"; /** 如果有了，直接引用 */

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

String s3 = new String();

s3 = "abc"; /** 如果有了，直接引用 */

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

System.out.println(s2 == s3); // true

String s4 = new String("abc"); /** 通过new得到的，都是开辟新内存。堆内存 */

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

System.out.println(s2 == s4); // false

System.out.println(s3 == s4); // false

s4 = "abc"; /** 如果有了，直接引用 */

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

/**------------------编译与运行--------------------------*/

String str1 = "a" + "b" + "c" + "d"; // 编译阶段，这里会被合并为“abcd”

String str2 = "abcd";

System.out.println(str1 == str2); // true

/**------------------“自动装箱”--------------------------*/

String string1 = "ab"; // 保存进String池

String string2 = "cdef"; // 保存进String池

/** 下面的执行为：

* StringBuilder sb = new StringBuilder(string1).append(string2);

* String string3 = sb.toString(); */

String string3 = string1 + string2; // 通过方法返回的对象，在堆内存

System.out.println(string3 == "abcdef"); // false

}


	int arr[] ={3,2,15,6,3};
	// 传统for
	for (int i = 0; i < arr.length; i++) {
		System.out.println(arr[i]);
	}
	System.out.println("------------------------");
	// 增强for
	for (int i : arr) {
		System.out.println(i);
	}

1

2

3

4

5

6

7

8

9

10

11

12

int arr[] ={3,2,15,6,3};

// 传统for

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

System.out.println(arr[i]);

}

System.out.println("------------------------");

// 增强for

for (int i : arr) {

System.out.println(i);

}


	Collection col = new ArrayList();
	col.add("df");
	col.add("2345");
	col.add("Gngfdj");
	col.add("876");
	
	// 传统集合遍历
	Iterator iterator = col.iterator();		// 1.得到迭代器
	while(iterator.hasNext()){			// 2.判断是否还有有效元素
		System.out.println(iterator.next());	// 3.得到元素
	}
	
	System.out.println("=========================");
	
	// 增强for
	for (Object object : col) {
		System.out.println(object);
	}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

Collection col = new ArrayList();

col.add("df");

col.add("2345");

col.add("Gngfdj");

col.add("876");

// 传统集合遍历

Iterator iterator = col.iterator(); // 1.得到迭代器

while(iterator.hasNext()){ // 2.判断是否还有有效元素

System.out.println(iterator.next()); // 3.得到元素

}

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

// 增强for

for (Object object : col) {

System.out.println(object);

}


public static void main(String[] args) {
	Map map = new HashMap();
	map.put("a", "AAA");
	map.put("b", "BBB");
	map.put("c", "CCC");
	map.put("d", "DDD");
	
	// 传统遍历方式一
	Set keySet = map.keySet();			// 1.得到KeySet集合
	Iterator keys = keySet.iterator();		// 2.得到迭代器
	while(keys.hasNext()){				// 3.判断是否还有有效元素
		Object key = keys.next();		// 4.得到元素的key
		Object value = map.get(key);		// 5.通过key得到value
		System.out.println(key + "-" + value);	// d-DDD b-BBB c-CCC a-AAA
	}
	System.out.println("=========================");
	
	// 传统遍历方式二
	Set entrySet = map.entrySet();			// 1.得到EntrySet集合
	Iterator entries = entrySet.iterator();		// 2.得到迭代器
	while(entries.hasNext()){			// 3.判断是否还有有效元素
		Entry entry = (Entry) entries.next();	// 4.得到一条记录
		Object key = entry.getKey();		// 5.得到记录中的key
		Object value = entry.getValue();	// 6.得到记录中的value
		System.out.println(key + "->" + value);	// d->DDD b->BBB c->CCC a->AAA
	}
	System.out.println("++++++++++++++++++++++++");
	
	/** 增强for。实现Iterator的集合即可使用增强for **/
	for (Object object : map.entrySet()) {
		System.out.println(object);	// d=DDD b=BBB c=CCC a=AAA
	}
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

public static void main(String[] args) {

Map map = new HashMap();

map.put("a", "AAA");

map.put("b", "BBB");

map.put("c", "CCC");

map.put("d", "DDD");

// 传统遍历方式一

Set keySet = map.keySet(); // 1.得到KeySet集合

Iterator keys = keySet.iterator(); // 2.得到迭代器

while(keys.hasNext()){ // 3.判断是否还有有效元素

Object key = keys.next(); // 4.得到元素的key

Object value = map.get(key); // 5.通过key得到value

System.out.println(key + "-" + value); // d-DDD b-BBB c-CCC a-AAA

}

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

// 传统遍历方式二

Set entrySet = map.entrySet(); // 1.得到EntrySet集合

Iterator entries = entrySet.iterator(); // 2.得到迭代器

while(entries.hasNext()){ // 3.判断是否还有有效元素

Entry entry = (Entry) entries.next(); // 4.得到一条记录

Object key = entry.getKey(); // 5.得到记录中的key

Object value = entry.getValue(); // 6.得到记录中的value

System.out.println(key + "->" + value); // d->DDD b->BBB c->CCC a->AAA

}

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

/** 增强for。实现Iterator的集合即可使用增强for **/

for (Object object : map.entrySet()) {

System.out.println(object); // d=DDD b=BBB c=CCC a=AAA

}

威格灵

一。基本数据类型手动装箱拆箱、自动装箱拆箱

二。数据类型缓冲池

1。基本数据类型缓冲池

2。String缓冲池

三。增强for循环

1。数组

2。单列集合

3。双列集合