一、静态导入
1. 导入类的静态属性
import static java.lang.System.out;
out.println("haha");
2. 导入类的静态方法
import static java.lang.Math.*; // 导入Math类的所有静态成员
int num = abs(-10);
二、基本数据类型的包装类
1. Integer x = 1; x = x + 1; 经历了什么过程？ 装箱à 拆箱 à 装箱
2. 为了优化，虚拟机为包装类提供了缓冲池， Integer池的大小 -128~127
3. String池
1. String s = "abc"， 虚拟机首先会检查String池里有没有"abc"对象(通过equals方法)
// 如果有，直接返回引用，如果没有，会在池里创建一个“abc”对象，并返回引用
String s1 = "abc";
String s2 = "abc";
System.out.println(s1==s2); // result: true
2. String str = new String("abc"); 不管缓冲池是否有"abc", 都会在堆内存创建一个"abc"对象，返回引用
// 此时，负责检查并维护缓冲池，其实堆内存的对象是缓冲池中"abc"对象的一个拷贝
String s1 = new String("abc");
String s2 = new String("abc");
System.out.println(s1==s2); // result: false
3. String s = "a" + "b" + "c" + "d"; java编译器有个合并已知量的优化功能
// 在编译阶段就把"a" + "b" + "c" + "d" 合并为 ”abcd“
String s = "a" + "b" + "c" + "d";
// String s = "abcd";
System.out.println(s=="abcd");// result: true
4. String s1 = "a"; String s2 = "b"; String s3 = s1 + s2;
// String是常量，不能相加的，java如何实现的？
StringBuilder sb = new StringBuidler(s1);
sb.append(s2);
s3 = sb.toString();
也就是说实际上s3是方法返回的String对象
凡是方法返回的字符串对象都是在堆内存的，并且不负责维护缓冲池
String s1 = "a";
String s2 = "b";
String s3 = s1 + s2; // 堆内存的对象
System.out.println(s3=="ab");// result: false
①String tmp = "a" + "b" + "c";
②String tmp = null;
tmp+= "a";
tmp+= "b";
tmp+= "c";
③String tmp = null;
StringBuffer buf = new StringBuffer（）；
buf.append（"a"）；
buf.append（"b"）；
buf.append（"c"）；
tmp = buf.toString（）；
有些Java程序员在任意的用这三种方法的任一种，无视它们的区别。有些程序员知道第三种方法好，一直在用而不知其为什么好，以至于作为经验教条的传授给Java新手。真正的答案是什么呢？让我们揭开 String 和StringBuffer 的封装面纱，看看它的内部实现。
在Java中的String Class是一个不可变final类，所有对一个Sting Object的改变都会导致一个新的String Object的生成。那么对tmp+=a中+符号的实现呢？
如果你注意一下StringBuffer的Javadoc会发现，JDK对它的实现是：tmp=（new StringBuffer（）。append（tmp）。append（"a"））。toSting（）；
这样我们发现②这种方法在隐性生成了一个StringBuffer Object乘3和一个String Object 乘3就是六个object 的资源耗费。（还不包括String Class和StringBuffer Class内部使用的Char[]）。
而方法③只用了两个。也许有些程序员会对这些耗费不以为然，的确也是，不过在一些场景下它会成为perfamence的瓶颈。
再回头看看①这种方法，它会被Java编译器编译为：tmp=（new StringBuffer（）。append（"a"）。append（"b"）。append（"c"））。to String（）；我们发现做的和③方法是同样的事。
三、增强for循环
1. 作用： 对存储对象的容器进行迭代
2. jdk5以前怎么迭代
3. 数组
String [] arr = {"a", "b", "c"}; //数组的静态定义方式，只试用于数组首次定义的时候
// 传统方式
for(int i=0; i<arr.length; i++) {
// i依次表示数组的角标
String s = arr[i];
System.out.println(s);
}
System.out.println("-------------------------------------");
// 在jdk5中我们可以使用增强for循环迭代
// 增强for循环括号里写两个参数，第一个是声明一个变量，变量类型必须是数组元素的类型
// 第二个就是需要迭代的容器
// for循环会循环容器的length次, 每次都将容器的第n-1个元素赋值给声明的变量
for(String s : arr) {
// 循环体， 执行arr.length
// 每次都将arr中的第n-1个元素给s
System.out.println(s); //
}
4. 单列集合 Collection
List list = new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("ccc");
// 传统方式1
// 传统方式2
for(Iterator iter=list.iterator(); iter.hasNext(); ) {
String s = (String) iter.next();
System.out.println(s);
}
System.out.println("--------------------------------");
// 增强for循环, 没有使用泛型的集合能不能使用增强for循环迭代？能
for(Object obj : list) {
String s = (String) obj;
System.out.println(s);
}
5. 双列集合 Map
Map map = new HashMap();
map.put("a", "aaa");
map.put("b", "bbb");
map.put("c", "ccc");
// 传统方式迭代1
// 1. 获得所有的key
Set keys = map.keySet();
// 2.迭代keys获得所有的key
Iterator iter = keys.iterator();
while(iter.hasNext()) {
String key = (String) iter.next(); // a b c
// 3.根据key获得对应的value
String value = (String) map.get(key);
System.out.println(key + "=" + value);
}
System.out.println("---------------------------------");
// 传统方式2，必须掌握这种方式
// 1.获得所有的键值对Entry对象
Set entrys = map.entrySet();
// 2.迭代出所有的entry
iter = entrys.iterator();
while(iter.hasNext()) {
Map.Entry entry = (Entry) iter.next();
// 分别获得key和value
String key = (String) entry.getKey();
String value = (String) entry.getValue();
System.out.println(key + "=" + value);
}
System.out.println("-------------------------------------");
System.out.println("增强for循环迭代，");
// 增强for循环迭代，
// 原则上map集合是无法使用增强for循环来迭代的，
// 因为增强for循环只能针对实现了Iterable接口的集合进行迭代
// Iterable是jdk5中新定义的接口，就一个方法iterator方法
// 只有实现了Iterable接口的类，才能保证一定有iterator方法
// java有这样的限定是因为增强for循环内部还是用迭代器实现的
// 而实际上，我们可以通过某种方式来使用增强for循环
for(Object obj : map.entrySet()) {
// obj 依次表示Entry
Map.Entry entry = (Entry) obj;
System.out.println(entry.getKey() + "=" + entry.getValue());
}
6. 集合迭代注意问题
// 在使用迭代器迭代集合的过程中，不能对集合进行增删操作
@Test
public void test4() {
List list = new ArrayList();
list.add("wangwu");
list.add("zhangsan");
list.add("lisi");
Iterator iter = list.iterator();
while(iter.hasNext()) {
String name = (String) iter.next();
if("wangwu".equals(name)) {
// 从集合中删掉
//list.remove(name);
// 迭代过程中删除元素需要调用迭代器的方法
iter.remove(); // 删除我迭代的集合被我迭代的最后一个元素
}
}
// 1 2 4
System.out.println(list.size());
}
@Test
public void test5() {
List list = new ArrayList();
list.add("aa");
list.add("bb");
// 使用ListIterator迭代器
ListIterator listIterator = list.listIterator();
while(listIterator.hasNext()) {
listIterator.next();
// 迭代过程中增加元素
listIterator.add("cc");
}
System.out.println(list.size());
}
7. 增强for循环注意问题
//在使用增强for循环时，不能对元素进行赋值
int[] arr = {1,2,3};
for(int num : arr) {
num = 0;
}
System.out.println(arr[1]);