for（int i=0;i<arr.size();i++）{
	...
}

for（int　i：arr）{
	...
}

Iterator it = arr.iterator();
while(it.hasNext()){ 
	object o =it.next(); 
...}

Map map = new HashMap();
map.put("key1","lisi1");
map.put("key2","lisi2");
map.put("key3","lisi3");
map.put("key4","lisi4");  

Iterator it = map.keySet().iterator();
 //获取迭代器
while(it.hasNext()){
	Object key = it.next();
System.out.println(map.get(key));
}

Map map = new HashMap();
map.put("key1","lisi1");
map.put("key2","lisi2");
map.put("key3","lisi3");
map.put("key4","lisi4");

Iterator it = map.entrySet().iterator();
	while(it.hasNext()){
	Entry e =(Entry) it.next();
	System.out.println("键"+e.getKey () + "的值为" + e.getValue());
}

package MyTest01;
 
import java.util.ArrayList;
import java.util.List;
 
public class ListTest01 {
 
    public static void main(String[] args) {
         
            //list中添加，获取，删除元素
            List<String> person=new ArrayList<>();
            person.add("jackie");   //索引为0  //.add(e)
            person.add("peter");    //索引为1
            person.add("annie");    //索引为2
            person.add("martin");   //索引为3
            person.add("marry");    //索引为4
             
            person.remove(3);   //.remove(index)
            person.remove("marry");     //.remove(Object o)
             
            String per="";
            per=person.get(1);
            System.out.println(per);    ////.get(index)
             
            for (int i = 0; i < person.size(); i++) {
                System.out.println(person.get(i));  //.get(index)
            }
             
             
         
            //list总是否包含某个元素
            List<String> fruits=new ArrayList<>();
            fruits.add("苹果");
            fruits.add("香蕉");
            fruits.add("桃子");
            //for循环遍历list
            for (int i = 0; i < fruits.size(); i++) {
                System.out.println(fruits.get(i));
            }
            String appleString="苹果";
            //true or false
            System.out.println("fruits中是否包含苹果："+fruits.contains(appleString));
             
            if (fruits.contains(appleString)) {
                System.out.println("我喜欢吃苹果");
            }else {
                System.out.println("我不开心");
            }
             
            //list中根据索引将元素数值改变(替换)
            String a="白龙马", b="沙和尚", c="八戒", d="唐僧", e="悟空";
            List<String> people=new ArrayList<>();
            people.add(a);
            people.add(b);
            people.add(c);
            people.set(0, d);   //.set(index, element)      //将d唐僧放到list中索引为0的位置，替换a白龙马
            people.add(1, e);   //.add(index, element);     //将e悟空放到list中索引为1的位置,原来位置的b沙和尚后移一位
             
            //增强for循环遍历list
            for(String str:people){
                System.out.println(str);
            }
             
            //list中查看（判断）元素的索引
            List<String> names=new ArrayList<>();
            names.add("刘备");    //索引为0
            names.add("关羽");    //索引为1
            names.add("张飞");    //索引为2
            names.add("刘备");    //索引为3
            names.add("张飞");    //索引为4
            System.out.println(names.indexOf("刘备"));
            System.out.println(names.lastIndexOf("刘备"));
            System.out.println(names.indexOf("张飞"));
            System.out.println(names.lastIndexOf("张飞"));
             
            //根据元素索引位置进行的判断
            if (names.indexOf("刘备")==0) {
                System.out.println("刘备在这里");
            }else if (names.lastIndexOf("刘备")==3) {
                System.out.println("刘备在那里");
            }else {
                System.out.println("刘备到底在哪里？");
            }
             
            //利用list中索引位置重新生成一个新的list（截取集合）
            List<String> phone=new ArrayList<>();
            phone.add("三星");    //索引为0
            phone.add("苹果");    //索引为1
            phone.add("锤子");    //索引为2
            phone.add("华为");    //索引为3
            phone.add("小米");    //索引为4
            //原list进行遍历
            for(String pho:phone){
                System.out.println(pho);
            }
            //生成新list
            phone=phone.subList(1, 4);  //.subList(fromIndex, toIndex)      //利用索引1-4的对象重新生成一个list，但是不包含索引为4的元素，4-1=3
            for (int i = 0; i < phone.size(); i++) { // phone.size() 该方法得到list中的元素数的和
                System.out.println("新的list包含的元素是"+phone.get(i));
            }
             
            //对比两个list中的所有元素
            //两个相等对象的equals方法一定为true, 但两个hashcode相等的对象不一定是相等的对象
            if (person.equals(fruits)) {
                System.out.println("两个list中的所有元素相同");
            }else {
                System.out.println("两个list中的所有元素不一样");
            }
             
            if (person.hashCode()==fruits.hashCode()) {
                System.out.println("我们相同");
            }else {
                System.out.println("我们不一样");
            }
             
             
            //判断list是否为空
            //空则返回true，非空则返回false
            if (person.isEmpty()) {
                System.out.println("空的");
            }else {
                System.out.println("不是空的");
            }
             
            //返回Iterator集合对象
            System.out.println("返回Iterator集合对象:"+person.iterator());
             
            //将集合转换为字符串
            String liString="";
            liString=person.toString();
            System.out.println("将集合转换为字符串:"+liString);
             
            //将集合转换为数组，默认类型
            System.out.println("将集合转换为数组:"+person.toArray());
             
            ////将集合转换为指定类型（友好的处理）
            //1.默认类型
            List<Object> listsStrings=new ArrayList<>();
            for (int i = 0; i < person.size(); i++) {
                listsStrings.add(person.get(i));
            }
            //2.指定类型
            List<StringBuffer> lst=new ArrayList<>();
            for(String string:person){
                lst.add(StringBuffer(string));
            }
             
             
             
             
    }
 
    private static StringBuffer StringBuffer(String string) {
        return null;
    }
 
 
    }

//对 set 的遍历  
  
//1.迭代遍历：  
Set<String> set = new HashSet<String>();  
Iterator<String> it = set.iterator();  
while (it.hasNext()) {  
  String str = it.next();  
  System.out.println(str);  
}  
  
//2.for循环遍历：  
for (String str : set) {  
      System.out.println(str);  
}  
  
  
//优点还体现在泛型 假如 set中存放的是Object  
  
Set<Object> set = new HashSet<Object>();  
//for循环遍历：  
for (Object obj: set) {  
      if(obj instanceof Integer){  
                int aa= (Integer)obj;  
             }else if(obj instanceof String){  
               String aa = (String)obj  
             }  
              ........  
}

class FireWriterDemo {
	public static void main(String[] args) throws IOException {             //需要对IO异常进行处理 

		//创建一个FileWriter对象，该对象一被初始化就必须要明确被操作的文件。
		//而且该文件会被创建到指定目录下。如果该目录有同名文件，那么该文件将被覆盖。

		FileWriter fw = new FileWriter("F:\\1.txt");//目的是明确数据要存放的目的地。

		//调用write的方法将字符串写到流中
		fw.write("hello world!");
	
		//刷新流对象缓冲中的数据，将数据刷到目的地中
		fw.flush();

		//关闭流资源，但是关闭之前会刷新一次内部缓冲中的数据。当我们结束输入时候，必须close();
		fw.write("first_test");
		fw.close();
		//flush和close的区别：flush刷新后可以继续输入，close刷新后不能继续输入。

	}
}

class FileReaderDemo {
	public static void main(String[] args) {
		characters();
	}

/*****************字符数组进行读取*********************/
	private static void characters() {

		try {

			FileReader fr = new FileReader("Demo.txt");
			char []  buf = new char[6]; 
			//将Denmo中的文件读取到buf数组中。
			int num = 0;	
			while((num = fr.read(buf))!=-1) {

				//String(char[] value , int offest,int count) 分配一个新的String,包含从offest开始的count个字符
				sop(new String(buf,0,num));
			}
			sop('\n');
			fr.close();
		}
		catch (IOException e) {
			sop(e.toString());
		}
	}

/*****************单个字母读取*************************/
	private static void singleReader() {
		
		try {

			//创建一个文件读取流对象，和指定名称的文件关联。
			//要保证文件已经存在，否则会发生异常：FileNotFoundException
			FileReader fr = new FileReader("Demo.txt");

		
			//如何调用读取流对象的read方法？
			//read()方法，一次读取一个字符，并且自动往下读。如果到达末尾则返回-1
			int ch = 0;
			while ((ch=fr.read())!=-1) {
				sop((char)ch);
			}
			sop('\n');
			fr.close();

			/*int ch = fr.read();
			sop("ch=" + (char)ch);

			int ch2 = fr.read();
			sop("ch2=" + (char)ch2);

			//使用结束注意关闭流
			fr.close();	*/	
		}
		catch (IOException e) {
			sop(e.toString());
		}
	}

/**********************Println************************/
	private static void sop(Object obj) {
		System.out.print(obj);
	}

}

import java.io.*;

class  FileWriterDemo3 {
	public static void main(String[] args) {
		
		try {
			//传递一个参数,代表不覆盖已有的数据。并在已有数据的末尾进行数据续写
			FileWriter fw = new FileWriter("F:\\java_Demo\\day9_24\\demo.txt",true);
			fw.write(" is charactor table?");
			fw.close();
		}
		catch (IOException e) {
			sop(e.toString());
		}
		
	}

/**********************Println************************/
	private static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

import java.io.*;
import java.util.Scanner;

class CopyText {
	public static void main(String[] args) throws IOException {
		sop("请输入要拷贝的文件的路径:");
		Scanner in = new Scanner(System.in);
		String source = in.next();
		sop("请输入需要拷贝到那个位置的路径以及生成的文件名:");
		String destination = in.next();
		in.close();
		CopyTextDemo(source,destination);

	}

/*****************文件Copy*********************/
	private static void CopyTextDemo(String source,String destination) {

		try {
			FileWriter fw = new FileWriter(destination);
			FileReader fr = new FileReader(source);
			char []  buf = new char[1024]; 
			//将Denmo中的文件读取到buf数组中。
			int num = 0;	
			while((num = fr.read(buf))!=-1) {
                               //String(char[] value , int offest,int count) 分配一个新的String,包含从offest开始的count个字符
				fw.write(new String(buf,0,num));
			}
			fr.close();
			fw.close();
		}
		catch (IOException e) {
			sop(e.toString());
		}
	}

/**********************Println************************/
	private static void sop(Object obj) {
		System.out.println(obj);
	}
}

import java.io.*;


class BufferedReaderDemo {
	public static void main(String[] args)  throws IOException {

		//创建一个字符读取流流对象，和文件关联
		FileReader rw = new FileReader("buf.txt");

		//只要将需要被提高效率的流作为参数传递给缓冲区的构造函数即可
		BufferedReader brw = new BufferedReader(rw);

		
		for(;;) {
			String s = brw.readLine();
			if(s==null) break;
			System.out.println(s);
		}
		
		brw.close();//关闭输入流对象

	}
}

import java.io.*;


class BufferedWriterDemo {
	public static void main(String[] args)  throws IOException {

		//创建一个字符写入流对象
		FileWriter fw = new FileWriter("buf.txt");

		//为了提高字符写入效率，加入了缓冲技术。
		//只要将需要被提高效率的流作为参数传递给缓冲区的构造函数即可
		BufferedWriter bfw = new BufferedWriter(fw);

		//bfw.write("abc\r\nde");
		//bfw.newLine();               这行代码等价于bfw.write("\r\n"),相当于一个跨平台的换行符
		//用到缓冲区就必须要刷新
		for(int x = 1; x < 5; x++) {
			bfw.write("abc");
			bfw.newLine();					//java提供了一个跨平台的换行符newLine();
			bfw.flush();
		}



		bfw.flush();												//刷新缓冲区
		bfw.close();												//关闭缓冲区，但是必须要先刷新

		//注意，关闭缓冲区就是在关闭缓冲中的流对象
		fw.close();													//关闭输入流对象

	}
}

class MyBufferReader {
MyBufferReader (MyTextReader text) {}
    MyBufferReader (MyMediaReader media) {}
    MyBufferReader (MyDataReader data) {}
}

class MyBufferReader  extends MyReader{
    private MyReader r;                        //从继承变为了组成模式  装饰设计模式
    MyBufferReader(MyReader r) {}
}

class MyBufferedReader1  extends Reader{             
    private Reader r;
    MyBufferedReader1(Reader r){
        this.r  = r;
    }

    //一次读一行数据的方法
    public String myReaderline()  throws IOException {
        //定义一个临时容器，原BufferReader封装的是字符数组。
        //为了演示方便。定义一个StringBuilder容器。最终要将数据变成字符串
        StringBuilder sb = new StringBuilder();
        int ch = 0;
        while((ch = r.read()) != -1)
        {
            if(ch == '\r') 
                continue;
            if(ch == '\n')                    //遇到换行符\n,返回字符串
                return sb.toString();
            else
            sb.append((char)ch);
        }
        if(sb.length()!=0)                    //当最后一行不是以\n结束时候，这里需要判断
            return sb.toString();
        return null;
    }
    /*
    需要覆盖Reader中的抽象方法close()，read();
    */
    public void close()throws IOException {
        r.close();
    }

    public int read(char[] cbuf,int off, int len)throws IOException {   //覆盖read方法
        return r.read(cbuf,off,len);
    }

    public void myClose() throws IOException{
        r.close();
    }
}

public class MyThread extends Thread {  
　　public void run() {  
　　 System.out.println("MyThread.run()");  
　　}  
}  
 
MyThread myThread1 = new MyThread();  
MyThread myThread2 = new MyThread();  
myThread1.start();  
myThread2.start();  

public class MyThread extends OtherClass implements Runnable {  
　　public void run() {  
　　 System.out.println("MyThread.run()");  
　　}  
}  

MyThread myThread = new MyThread();  
Thread thread = new Thread(myThread);  
thread.start();  

public void run() {  
　　if (target != null) {  
　　 target.run();  
　　}  
}  

public interface Callable<V>   { 
  V call（） throws Exception;   
} 
public class SomeCallable<V> extends OtherClass implements Callable<V> {

    @Override
    public V call() throws Exception {
        // TODO Auto-generated method stub
        return null;
    }

}
Callable<V> oneCallable = new SomeCallable<V>();   
//由Callable<Integer>创建一个FutureTask<Integer>对象：   
FutureTask<V> oneTask = new FutureTask<V>(oneCallable);   
//注释：FutureTask<Integer>是一个包装器，它通过接受Callable<Integer>来创建，它同时实现了Future和Runnable接口。 
  //由FutureTask<Integer>创建一个Thread对象：   
Thread oneThread = new Thread(oneTask);   
oneThread.start();   
//至此，一个线程就创建完成了。

import java.util.concurrent.*;  
import java.util.Date;  
import java.util.List;  
import java.util.ArrayList;  
  
/ 
* 有返回值的线程 
*/  
@SuppressWarnings("unchecked")  
public class Test {  
public static void main(String[] args) throws ExecutionException,  
    InterruptedException {  
   System.out.println("----程序开始运行----");  
   Date date1 = new Date();  
  
   int taskSize = 5;  
   // 创建一个线程池  
   ExecutorService pool = Executors.newFixedThreadPool(taskSize);  
   // 创建多个有返回值的任务  
   List<Future> list = new ArrayList<Future>();  
   for (int i = 0; i < taskSize; i++) {  
    Callable c = new MyCallable(i + " ");  
    // 执行任务并获取Future对象  
    Future f = pool.submit(c);  
    // System.out.println(">>>" + f.get().toString());  
    list.add(f);  
   }  
   // 关闭线程池  
   pool.shutdown();  
  
   // 获取所有并发任务的运行结果  
   for (Future f : list) {  
    // 从Future对象上获取任务的返回值，并输出到控制台  
    System.out.println(">>>" + f.get().toString());  
   }  
  
   Date date2 = new Date();  
   System.out.println("----程序结束运行----，程序运行时间【"  
     + (date2.getTime() - date1.getTime()) + "毫秒】");  
}  
}  
  
class MyCallable implements Callable<Object> {  
private String taskNum;  
  
MyCallable(String taskNum) {  
   this.taskNum = taskNum;  
}  
  
public Object call() throws Exception {  
   System.out.println(">>>" + taskNum + "任务启动");  
   Date dateTmp1 = new Date();  
   Thread.sleep(1000);  
   Date dateTmp2 = new Date();  
   long time = dateTmp2.getTime() - dateTmp1.getTime();  
   System.out.println(">>>" + taskNum + "任务终止");  
   return taskNum + "任务返回运行结果,当前任务时间【" + time + "毫秒】";  
}  
}  

package com.java.reflection;

public class Person {
    String name;
    private int age;

    public Person() {
        System.out.println("无参构造器");
    }

    public Person(String name, int age) {
        System.out.println("有参构造器");
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

/**
 * 反射机制获取类有三种方法
 */
@Test
public void testGetClass() throws ClassNotFoundException {
    Class clazz = null;

    //1 直接通过类名.Class的方式得到
    clazz = Person.class;
    System.out.println("通过类名: " + clazz);

    //2 通过对象的getClass()方法获取,这个使用的少（一般是传的是Object，不知道是什么类型的时候才用）
    Object obj = new Person();
    clazz = obj.getClass();
    System.out.println("通过getClass(): " + clazz);

    //3 通过全类名获取，用的比较多，但可能抛出ClassNotFoundException异常
    clazz = Class.forName("com.java.reflection.Person");
    System.out.println("通过全类名获取: " + clazz);
}

/** 
 * Class类的newInstance()方法，创建类的一个对象。 
 */  
@Test  
public void testNewInstance()  
        throws ClassNotFoundException, IllegalAccessException, InstantiationException {  
  
    Class clazz = Class.forName("com.java.reflection.Person");  
  
    //使用Class类的newInstance()方法创建类的一个对象  
    //实际调用的类的那个 无参数的构造器（这就是为什么写的类的时候，要写一个无参数的构造器，就是给反射用的）  
    //一般的，一个类若声明了带参数的构造器，也要声明一个无参数的构造器  
    Object obj = clazz.newInstance();  
    System.out.println(obj);  
}  

/**
 * ClassLoader类装载器
 */
@Test
public void testClassLoader1() throws ClassNotFoundException, IOException {
    //1、获取一个系统的类加载器
    ClassLoader classLoader = ClassLoader.getSystemClassLoader();
    System.out.println("系统的类加载器-->" + classLoader);

    //2、获取系统类加载器的父类加载器(扩展类加载器（extensions classLoader）)
    classLoader = classLoader.getParent();
    System.out.println("扩展类加载器-->" + classLoader);

    //3、获取扩展类加载器的父类加载器
    //输出为Null,无法被Java程序直接引用
    classLoader = classLoader.getParent();
    System.out.println("启动类加载器-->" + classLoader);

    //

    //4、测试当前类由哪个类加载器进行加载 ,结果就是系统的类加载器
    classLoader = Class.forName("com.java.reflection.Person").getClassLoader();
    System.out.println("当前类由哪个类加载器进行加载-->"+classLoader);

    //5、测试JDK提供的Object类由哪个类加载器负责加载的
    classLoader = Class.forName("java.lang.Object").getClassLoader();
    System.out.println("JDK提供的Object类由哪个类加载器加载-->" + classLoader);
}

 @Test  
    public void testGetResourceAsStream() throws ClassNotFoundException, IOException {  
//          这么写的话，文件需要放到src目录下  
        //       InputStream in = new FileInputStream("test.properties");  
  
        //5、关于类加载器的一个主要方法  
        //调用getResourceAsStream 获取类路径下的文件对应的输入流  
        InputStream in = this.getClass().getClassLoader()  
                .getResourceAsStream("com/java/reflection/test.properties");  
        System.out.println("in: " +in);  
  
        Properties properties = new Properties();  
        properties.load(in);  
  
        String driverClass = properties.getProperty("dirver");  
        String jdbcUrl = properties.getProperty("jdbcUrl");  
        //中文可能会出现乱码，需要转换一下  
        String user = new String(properties.getProperty("user").getBytes("ISO-8859-1"), "UTF-8");  
        String password = properties.getProperty("password");  
  
        System.out.println("diverClass: "+driverClass);  
        System.out.println("user: " + user);  
    }  

public class Person {
    private String name;
    private int age;

    //新增一个私有方法
    private void privateMthod(){
    }
    
    public Person() {
        System.out.println("无参构造器");
    }

    public Person(String name, int age) {
        System.out.println("有参构造器");
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    /**
     * 
     * @param age  类型用Integer，不用int
     */
    public void setName(String name , int age){
        System.out.println("name: " + name);
        System.out.println("age:"+ age);

    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

@Test
public void testMethod() throws ClassNotFoundException, NoSuchMethodException, 
        IllegalAccessException, InstantiationException, InvocationTargetException {
    Class clazz = Class.forName("com.java.reflection.Person");

    //1、得到clazz 对应的类中有哪些方法,不能获取private方法
    Method[] methods =clazz.getMethods();
    System.out.print("        getMethods: ");
    for (Method method : methods){
        System.out.print(method.getName() + ", ");
    }

    //2、获取所有的方法(且只获取当着类声明的方法，包括private方法）
    Method[] methods2 = clazz.getDeclaredMethods();
    System.out.print("\ngetDeclaredMethods: ");
    for (Method method : methods2){
        System.out.print(method.getName() + ", ");
    }

    //3、获取指定的方法
    Method method = clazz.getDeclaredMethod("setName",String.class);//第一个参数是方法名，后面的是方法里的参数
    System.out.println("\nmethod : " + method);

    Method method2 = clazz.getDeclaredMethod("setName",String.class ,int.class);//第一个参数是方法名，后面的是方法里的参数
    System.out.println("method2: " + method2);

    //4、执行方法！
    Object obj = clazz.newInstance();
    method2.invoke(obj, "changwen", 22);
}