String池与iterator对集合的迭代

一、静态导入

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]);