1.删除后三只羊
    int num = sheepList.size(); 

        System.out.println("从后向前删:");

        for(int i = num - 1;i >= num - 3;i --){
            sheepList.remove(i);        
        }
        for(Object s:sheepList){
            System.out.println(((Sheep)s).name);
        }

        System.out.println("从前向后删");
        for(int i = 0;i < num - 3;i ++){
                sheepList.remove(0);
        }for(Object s:sheepList){
            System.out.println(((Sheep)s).name);
        }

        System.out.println("foreach:");
        int i = 0;
        for(Object s:sheepList){            
            if(i >= 3){
                sheepList.remove(((Sheep)s).name);
            }else{
                System.out.println(((Sheep)s).name);        
            }
            i ++;
        }

        Iterator it = sheepList.iterator();
        System.out.println("通过迭代器遍历:");
        for(int i = num - 1;i > num - 3;i --){
            if(i <= 3){
                sheepList.remove(i);
            }
            while(it.hasNext()){
                Sheep csn = (Sheep)it.next();
                System.out.println(csn.name);
            }
        }

    2.自动写文件   
        public static void main(String[] args) throws IOException{
        //创建目标文件
        File Demo = new File("e://YQ");
        if(!Demo.exists()){
            Demo.mkdir();
        }
        for(int i = 0;i < 10;i ++){
            File file = new File("e://YQ//yq" + i + ".txt");
            if(!file.exists()){
                file.createNewFile();           
            }
        }

        String[] filenames = Demo.list();
        for(int i = 0;i < filenames.length;i ++){
            FileOutputStream fos = new FileOutputStream("e://YQ//yq" + i + ".txt");
            String s = "我真" + i;
            fos.write(s.getBytes());
            fos.close();
            System.out.println("第" + i + "次写入完成");
        }   

    }

3.线程实现方法继承Thread与接口Runnnale的区别      
    public static void main(String[] args) {
        //数据独立,其数值分别为3,2,1
        Threadexend person1 = new Threadexend("关公");
        Threadexend person2 = new Threadexend("秦琼");
        person1.start();
        person2.start();

        //对象唯一，数据共享，数值一共是3,2,1
        IThread person3 = new IThread();
        new Thread(person3,"奥特曼").start();
        new Thread(person3,"小怪兽").start();
    }

    static class Threadexend extends Thread{
        public Threadexend(String name){
            super(name);
        }
        public Threadexend(){
            super();
        }
        private int nuqi = 3;
        public void run(){
            for(int i = 1;i <= 3;i ++){
                if(nuqi > 0){
                    System.out.println(getName() +"第" + i + "次打了对方" + "," + "剩余怒气值" + nuqi--);
                }
            }       
        }

int length = sheepList.size();                 
int n = 3;
//方法1:从前向后删n只羊
for(int i=0;i<n;i++){       
  sheepList.remove(i);
}
//方法2:从后向前删n只羊
for(int i=length;i>length-n-1;i--){    
 sheepList.remove(i);
}    
//方法3:使用迭代器删除后n只羊                                        
int count = 0;                   
Iterator<Sheep> itr = sheepList.iterator();
while(itr.hasNext()){
    if(count >= length - n){
        Sheep ed = (Sheep)itr.next();
        itr.remove();
    }else{
        itr.next();
        count++;
    }
}
//方法4:使用迭代器删除指定的3只羊   
Iterator<Sheep> itr = sheepList.iterator(); 
while(itr.hasNext()){
        Sheep sp = (Sheep)itr.next();
    if(sp.getName()=="懒羊羊"||sp.getName()=="慢羊羊"||sp.getName()=="沸羊羊")
        itr.remove();       
}
//方法5直接删除同一个索引3次即可删除3只羊(注意不可超过最大数)
sheepList.remove(2);  //这里删的为第3只羊,删3次
sheepList.remove(2);
sheepList.remove(2);

for(int i=0;i<9;i++){    //设置自动生成10个文件(0-9)
    file=new File(manyfile,"helloworld"+i+".txt");//manyfile为文件路径
    OutputStream out=null;
    try {
        out = new FileOutputStream(file);
        String s = "我是"+i;    //写入文件的内容
        try {
            out.write(s.getBytes());
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
} 

public class MyThread extends Thread{
    public static void main(String[] args) {
        Thread th1 = new ThreadExtend("Thread***1***");
        Thread th2 = new ThreadExtend("Thread***2***");
        Thread th3 = new ThreadExtend("Thread***3***");
        th1.start();
        th2.start();
        th3.start();
        ThreadImp1 ti = new ThreadImp1("runner***1***");
        Thread t1= new Thread(ti);
        Thread t2 = new Thread("runner***2***");
        Thread t3 = new Thread(new ThreadImp1("runner***3***"));
        t1.start();
        t2.start();
        t3.start();
    }
}
class ThreadImp1 implements Runnable{   //实现Runable接口
    public  String name;
    ThreadImp1(){
        this.name = "";
    }
    public ThreadImp1(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    @Override
    public void run(){
        for(int i=0;i<100;i++){
            System.out.println("我是"+this.getName()+i);
        }
    }
}

class ThreadExtend extends Thread{    //继承Thread类
    public ThreadExtend(String name){
        super(name);
    }
    public ThreadExtend(){
    }
    public void run(){
        for(int i=0;i<100;i++){
            System.out.println("我是"+this.getName()+i); 
        }
    }
}

//从后向前数删除n个
    int n=2;
    int lengh=sheepList.size();
    for(int i=lengh-1;i>lengh-n-1;i--)
    {
        sheepList.remove(i);
    }

    //删掉指定名字的羊
    Iterator it=sheepList.iterator();
    while(it.hasNext())
    {
        sheep sp=(sheep)it.next();
        if(sp.getName()=="慢羊羊")
        it.remove();
    }

    //从前面数删除p只羊
    int p=2;
    for(int i=0;i<p;i++)
    {
        sheepList.remove(0);
    }

File file=null;
        for(int i=0;i<9;i++)
        {
            file=new File ("helloworld"+i+".txt");
            FileOutputStream os=null;
            try {
                os=new FileOutputStream(file);
                String s="我真"+i;
                try {
                    os.write(s.getBytes());
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }   

public class MyThread {
    public static void main(String[] args) {
        ThreadExtend te=new ThreadExtend("Thread***1");
        ThreadExtend te1=new ThreadExtend("Thread***2");
        ThreadExtend te2=new ThreadExtend("Thread***3");
        te.start();
        te1.start();
        te2.start();
        ThreadImpl ti=new ThreadImpl();
        Thread t=new Thread(ti);
        Thread t2=new Thread(ti);
        t.start();
        t2.start();
    }
}

class ThreadImpl implements Runnable{
    private int i;
    @Override
    public void run() {
        for(;i<100;i++){
            System.out.println(Thread.currentThread().getName()+"***"+i);
            }
        }
}

class ThreadExtend extends Thread{
    public ThreadExtend(){
    }
    public ThreadExtend(String name){
        super(name);
    }
    public void run(){
        for(int i=0;i<5;i++){
            System.out.println("我是"+this.getName()+"*****"+i);
        }
    }
}

1.删除后三只羊
        //第一种方法
        int count=sheeplist.size();
        for(int i=count-1;i>=count-3;i--){
            sheeplist.remove(i);
        }
        //第二种方法
        for(int i=sheeplist.size()-3;i<sheeplist.size();){
            sheeplist.remove(i);
        }
        //第三种方法
        int count1=0;
        while(count1<3){
            sheeplist.remove(sheeplist.size()-1);
            count++;
        }
        //第四种方法
        int count2=sheeplist.size();
        for(int i=0;i<sheeplist.size();i++){
            while(i==count2-3){
                sheeplist.remove(i);
                i=i-1;
            }
        }
2.自动写文件
for(int i=0;i<10;i++){
        File filei=new File(files, "helloworld"+i+".txt");
        try {
            OutputStream os=new FileOutputStream(filei);
            String s="我真";
            s=s+i;
            os.write(s.getBytes());
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
3.线程实现方法继承Thread与接口Runnnale的区别
(1)继承自Thread
        ThreadExtend t1=new ThreadExtend("窗口一");
        ThreadExtend t2=new ThreadExtend("窗口二");
        ThreadExtend t3=new ThreadExtend("窗口三");
        t1.start();
        t2.start();
        t3.start();
class ThreadExtend extends Thread{
    private int tickets=5;
    public ThreadExtend(String name) {
        super(name);
    }
    @Override
    public void run() {
        while(this.tickets>0){
            this.tickets--;
        System.out.println("票在"+this.getName()+"被卖出");
        }
    }
}
(2)Runnable接口
        ThreadExtend t=new ThreadExtend();
        Thread c1=new Thread(t,"Runnable1");
        Thread c2=new Thread(t,"Runnable2");
        Thread c3=new Thread(t,"Runnable3");
        c1.start();
        c2.start();
        c3.start();
class ThreadExtend implements Runnable{
    private int ticket=5;
    @Override
    public void run() {
        while(this.ticket>0){
            this.ticket--;
        System.out.println("票在"+Thread.currentThread().getName()+"被卖出");
        }
        }

}
继承自Thread只能是单继承，每个线程之间是独立的；Runnnale接口可以实现线程间的资源共享。

    int length=sheepList.size();
    Scanner reader=new Scanner(System.in);
    int number=reader.nextInt();
    //使用Collection的子类List,List有序的可重复
    ArrayList<Sheep> sheepList1=new ArrayList<sheep>();
    List<sheep>sheepList=sheepList1;
//遍历一遍羊的个数，因为是有序的所以有两种方法
//方法一:下标索引遍历
    for(int i=0;i<length;i++){
        System.out.println(i);
    }
//方法二:使用迭代器遍历删除
    Iterator<sheep>it=set.iterator();
    if(it.hasNext()){
        String s=it.next();
        it.remove();
        System.out.println("删除的元素为"+s);
    }
//删羊
//方法一:正常删除顺序，删除number个
    for(int i=0;i<number;i++){
        sheepList.remove(i);//因为List是有序的，所以可以使用下标索引
    }
//方法二:从后向前删number只羊
    for(int i=length;i>=length-number;i--){
        sheepList.remove(i);
    }

//IO的普通操作
    FileInputStream fis=null;
    FileOutputStream fos=null;
    //IO异常是checkException，需要显性做出处理异常
    try{
        //生成输入流的对象
        fis=new FileInputStream("e:hello.txt");
        //生成输出流的对象
        fos=new FileOutputStream("e:hello1.txt");
        //生成一个字节数组
        byte[] buffer=new byte[1024];
        while(true){
            int temp=fis.read(buffer,0,buffer.length);
            if(temp==-1){
                break;
            }
            fos.write(buffer,0,temp);
        }
    catch(IOException e){
        System.out.println(e);
    }
    finally｛
        try{//仍然是checkException,所以关闭时候也要捕获异常
            fis.close();
            fos.close();
        }
        catch{
            System.out.println(e);
        }
    ｝
//自动写文件
for(int i=0;i<9;i++){    //设置自动生成10个文件(0-9)
    file=new File(manyfile,"helloworld"+i+".txt");//manyfile为文件路径
    OutputStream out=null;
    try {
        out = new FileOutputStream(file);
        String s = "我是"+i;    //写入文件的内容
        try {
            out.write(s.getBytes());
        } 
        catch (IOException e) {
            e.printStackTrace();
        }
    } 
    catch (FileNotFoundException e) {
        e.printStackTrace();
    }
    finally｛
        try{//仍然是checkException,所以关闭时候也要捕获异常
            out.close();
        }
        catch{
            System.out.println(e);
        }
    ｝
}       

//创建线程的方法一

    //定义一个线程类，它继承Thread并重新其中的run()方法。
    class FirstThread extends Thread {
        public void run(){
            for(int i=0;i <100;i++){
                System.out.println("FirstThread-->"+i);
            }
        }
    }

    public static void main(String args[]){
        //生成线程对象
        FirstThread firstThread=new FirstThread();
        //启动线程
        firstThread.start();

        //主方法也是一个线程
        for(int i=0;i <100;i++){
            System.out.println("main-->"+i);
        }
    }
//创建线程的方法二

    /*提供一个实现接口Runnable的类作为线程的目标对象，在初始化一个Thread类或者Thread子类的线程对象时，把目标
对象传递给这个线程的实例，由该目标对象提供线程体*/

    class SecondThread implements Runnable{
        public void run(){
            for(int i=0;i<100;i++){
                System.out.println("SecondThread-->"+i);
            }
        }
    }


    public static void main(String args[]){
        //生成一个Runnable接口实现类的对象
        SecondThread two =new SecondThread();
        //生成一个Thread对象，并将twoz作为参数传递给Thread对象
        Thread t=new Thread(two);
        //执行线程
        t.start();
    }

int len=sheepList.size();
int count=0;
Iterator<Sheep> itr=sheepList.iterator();
while(itr.hasNext()){
    if(count>len-4){
        itr.next();
        itr.remove();
    }
    else {itr.next();
    count++;
    }
}

package cn.edu.nuc.NewClass4;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class test {

public static void main(String[] args) {
        // TODO Auto-generated method stub
        File file = new File("E:\\Android\\Eclipse_workspace\\NewClass4\\iotest");
        File file1 = new File("E:\\Android\\Eclipse_workspace\\NewClass4\\iotest\\1\\2");
        File file2 = new File("E:\\Android\\Eclipse_workspace\\NewClass4\\iotest\\helloworld.txt");
        File file3 = new File("E:\\Android\\Eclipse_workspace\\NewClass4\\iotest\\1\\2\\helloworld1.txt");
        File file4 = new File("E:\\Android\\Eclipse_workspace\\NewClass4\\iotest\\1\\2\\helloworld2.txt");
        File file5 = new File("E:\\Android\\Eclipse_workspace\\NewClass4\\iotest\\1\\2\\helloworld3.txt");
        File file6 = new File("E:\\Android\\Eclipse_workspace\\NewClass4\\iotest\\1\\2\\helloworld4.txt");
        try {
            file.mkdir();
            file1.mkdirs();
            file2.createNewFile();
            file3.createNewFile();
            file4.createNewFile();
            file5.createNewFile();
            file6.createNewFile();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        String[] name=file.list();
        for(int i=0;i<name.length;i++){
            System.out.println(name[i]);
        }
        OutputStream IO = null;
        File[] Name=null;
        Name=file1.listFiles();
        System.out.println(Name.length);
        for(int i=0;i<Name.length;i++){
        try {
            IO=new FileOutputStream(Name[i], true);
            String s="中北大学安卓实验室";
            IO.write(s.getBytes());
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }try {
            IO.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        }
    }
}

package cn.edu.nuc.NewClass5;
public class test {
public static void main(String[] args) {
        // TODO Auto-generated method stub
        ThreadExtend H1=new ThreadExtend("一号");
        ThreadExtend H2=new ThreadExtend("二号");
        ThreadExtend H3=new ThreadExtend("三号");
        H1.start();
        H2.start();
        H3.start();
        ThreadImpl h=new ThreadImpl("一号");
        new Thread(h).start();
        new Thread(h).start();
        new Thread(h).start();
    }
}
class   ThreadImpl implements Runnable{
    private int number =10;
    private String name;
    public ThreadImpl(String name) {
        this.name = name;
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        System.out.println("我是实现Runnable");
        for(int i=0;i<10;i++){
            System.out.println("Runnable线程："+this.name+",i="+number--);
            if(number<1)
                break;
        }
    }
}
class   ThreadExtend extends Thread{
    private int number =10;
    public ThreadExtend(String name){
        super(name);
    }
    public ThreadExtend(){
        super();
    }
    public void run(){
        for(int i=0;i<10;i++){
            if(number<1)
                break;
            System.out.println("Thread线程:"+this.getName()+number--);
        }
    }
}

        int lenth=sheepList.size()-1;    //1从前向后删
//      for(int i=lenth;i>lenth-3;i--){
//          sheepList.remove(lenth-2);
//      }

//      for(int i=lenth;i>lenth-3;i--){  //2从后向前删
//          sheepList.remove(i);
//      }

        for(int i=lenth-3;i<lenth;i++){  //3从后向前删
            sheepList.remove(sheepList.size()-1);
        }

        Iterator<Sheep> itr=sheepList.iterator();                          //迭代器
        int n=0;
        while(itr.hasNext()){
            if(n>lenth-3){
                Object o=itr.next();
                System.out.println(((Sheep)o).name);
                itr.remove();
            }
            else{
                itr.next();
                n++;
            }
        }

        for(int i=0;i<9;i++){
                file=new File(manyfile,"helloworld"+i+".txt");
                OutputStream out=null;
                try {
                    out=new FileOutputStream(file);
                    String s="我真"+i;
                    try {
                        out.write(s.getBytes());
                    } catch (IOException e) {
                // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                } catch (FileNotFoundException e) {
                // TODO Auto-generated catch block
                    e.printStackTrace();
                }
        } 

    public static void main(String[] args) {
         ThreadExtend h1=new ThreadExtend("one");
        ThreadExtend h2=new ThreadExtend("two");
        ThreadExtend h3=new ThreadExtend("three");
        h1.start();
        h2.start();
        h3.start();
        ThreadImp1 thr=new ThreadImp1();
        Thread r1=new Thread(thr);
        Thread r2=new Thread(thr);
        Thread r3=new Thread(thr);
        r1.start();
        r2.start();
        r3.start();
    }
}

class ThreadImp1 implements Runnable{
    public void run(){
        for(int i=0;i<100;i++){
            System.out.println("我是runner"+i);
        }
    }

}


class ThreadExtend extends Thread{
    public ThreadExtend(String name){
        super(name);
    }
    public ThreadExtend(){
        super();
    }

    public void run(){
        for(int i=0;i<100;i++){
            System.out.println("我是"+this.getName()+i);
        }
    }

//Delete_Sheep================================================
        ArrayList<sheep> sheeplist=new ArrayList<sheep>();
        sheeplist.add(new sheep("1"));
        sheeplist.add(new sheep("2"));
        sheeplist.add(new sheep("3"));
        sheeplist.add(new sheep("4"));
        sheeplist.add(new sheep("5"));
        sheeplist.add(new sheep("6"));
        int i=0;
//  /*方法一*/：for(i=5;i>2;i--)
//          sheeplist.remove(sheeplist.get(i));
//      
//      
//  /*方法二*/：for(i=0;i<3;i++)
//          sheeplist.remove(sheeplist.get(3));
//          
//  /*方法三*/：while(sheeplist.size()!=3)
//          sheeplist.remove(sheeplist.get(3));

        for(i=0;i<3;i++)
        System.out.println(((sheep)(sheeplist.get(i))).getName());


//======================================================================
//Create_FileAuto=========================================================
public class fileTEST {
    public static void main(String[] args) {
        //建立hello world文件
        File manyfile=new File("D:\\test");
        manyfile.mkdir();
        File file = null;
        try {
            manyfile.mkdir();
            for(int i=0;i<10;i++)
            {
                file=new File(manyfile,"helloworld"+i+".txt");
                file.createNewFile();
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }


        try {

            for(int i=0;i<10;i++)
            {
                OutputStream os=new FileOutputStream("D:\\test\\helloworld"+i+".txt");
                String s="andriod lab"+i;
                os.write(s.getBytes());

            }
        } 
        catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();

            }
        catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();

        }




        try {
            InputStream is=new FileInputStream("D:\\test\\helloworld"+0+".txt");
            byte[] read=new byte[1024];
            is.read(read);
            System.out.println();

        } catch (Exception e) {
            // TODO: handle exception
        }       


    }

}
//============================================================
//Threads=====================================================
public class cyh {
    public static void main(String[] args) {
        threadx thread1=new threadx();
        threadx thread2=new threadx();
        thread1.start();
        thread2.start();

        thready thread3=new thready();
        thready thread4=new thready();
        Thread thread5=new Thread(thread3);
        Thread thread6=new Thread(thread4);
        thread5.start();
        thread6.start();

    }

}


class threadx extends Thread{
    public void run(){
        System.out.println("openThread");
    }
    static int a=0;


}

class s{

}
class thready extends s implements Runnable{
    public void run() {
        System.out.println("openRunnable");

    }
}

    int n=2;
    int lengh=sheepList.size();
    for(int i=lengh-1;i>lengh-n-1;i--)
    {
        sheepList.remove(i);
    }

    Iterator it=sheepList.iterator();
    while(it.hasNext())
    {
        sheep sp=(sheep)it.next();
        if(sp.getName()=="慢羊羊")
        sheepList.remove(sp);
    }

    int p=2;
    for(int i=0;i<p;i++)
    {
        sheepList.remove(0);
    }

 for(int i=0;i<9;i++){
                file=new File(manyfile,"helloworld"+i+".txt");
                OutputStream out=null;
                try {
                    out=new FileOutputStream(file);
                    String s="我真"+i;
                    try {
                        out.write(s.getBytes());
                    } catch (IOException e) {
                // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                } catch (FileNotFoundException e) {
                // TODO Auto-generated catch block
                    e.printStackTrace();
                }
        } 

public static void main(String[] arge){
    ThreadExtend th=new ThreadExtend("1--");
    ThreadExtend th1=new ThreadExtend("2--");
    ThreadExtend th2=new ThreadExtend("3--");
    th.start();
    th.start();
    th1.start();
    th2.start();
    Thread th3=new Thread(new ThreadImpl("1--"));
    Thread th4=new Thread(new ThreadImpl("2--"));
    Thread th5=new Thread(new ThreadImpl("3--"));
    th3.start();
    th3.start();
    th4.start();
    th5.start();
    }
}

class ThreadImpl implements Runnable{
    private String name;
    public ThreadImpl(String name){
        this.name=name;
    }
    public ThreadImpl(){

    }

public void run() {
    // TODO Auto-generated method stub
    for(int i=0;i<100;i++){
        System.out.println("i am"+this.getName()+i);
        }   
    }
private String getName() {
    // TODO Auto-generated method stub
    return name;
}

}

class ThreadExtend extends Thread{
    public ThreadExtend(String name){
        super(name);
    }
    public ThreadExtend(){
        super();
    }
    public void run() {
        // TODO Auto-generated method stub
        for(int i=0;i<100;i++){
            System.out.println("i am"+this.getName()+i);
        }
    }

int lenth=sheepList.size()-1;                  //1从前向后删
//for(int i=lenth;i>lenth-3;i--){
//  sheepList.remove(lenth-2);
//}

//for(int i=lenth;i>lenth-3;i--){                 //2从后向前删
//  sheepList.remove(i);
//}

for(int i=lenth-3;i<lenth;i++){                //3从后向前删   
    sheepList.remove(sheepList.size()-1);
}   

for(int i=0;i<9;i++){
    file=new File(manyfile,"helloworld"+i+".txt");
    OutputStream out=null;
    try {
        out=new FileOutputStream(file);
        String s="我真"+i;
        try {
            out.write(s.getBytes());
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
} 

public static void main(String[] args) {
//  ThreadExtend h1=new ThreadExtend("one");
//  ThreadExtend h2=new ThreadExtend("two");
//  ThreadExtend h3=new ThreadExtend("three");
//  h1.start();
//  h2.start();
//  h3.start();
    Thread r1=new Thread(new ThreadImp1());
    Thread r2=new Thread(new ThreadImp1());
    Thread r3=new Thread(new ThreadImp1());
    r1.start();
    r2.start();
    r3.start();
}

class ThreadImp1 implements Runnable{
    public void run(){
        for(int i=0;i<100;i++){
            System.out.println("我是runner"+i);
        }
    }
}


class ThreadExtend extends Thread{
    public ThreadExtend(String name){
        super(name);
    }
    public ThreadExtend(){
        super();
    }

    public void run(){
        for(int i=0;i<100;i++){
            System.out.println("我是"+this.getName()+i); //???
        }
    }
}

    //利用迭代器遍历羊群并删除。
        int i;
        public void Iterator{
            Sheep[] sheep = new Sheep[] {new Sheep("喜羊羊"), new Sheep("美羊羊"), new Sheep("慢羊羊"), new Sheep("沸羊羊"),
            new Sheep("懒羊羊")};
            Iterator sum=sheep.Iterator();
            while(sum.hasNext()){
                Sheep sheep=(Sheep)sum.next();  
                sum.remove();
            }
        }

        //寻常的for循环从前向后删
        for(i=1;i<sheepList.size()+1;i++){
            sheepList.remove(i);
        }

        //从后向前删
        for(i=sheepList.size()-1;i>0;i--){
            sheepList.remove(i);
        }

       //  先生成文件，然后再执行出错跟踪和输入操作。
        int a;
        Scanner reader=new Scanner(System.in);
        a=reader.nextInt();
        while(a){
            File file=new File("D://helloworld"+i+".txt");
            OutputStream outputstream=null;
            try{
                outputstream=new FileOutputStream(file);
                String s="我是"+i;    
                outputstream.write(s)
            }
            catch(IOException e){
                e.printStackTrace();
            }
            finally{
                try{
                    file.close();
                }
                catch(IOException e){
                    e.printStackTrace()
                }
            }

        }

          //Thread和Runnable的区别：
          //         Thread是类，在Thread中只能利用start方法实现run方法，且在执行时需要等待。
         //          Runnable是接口，被继承时需要重写run方法，在现实该方法时也要利用start方法，且在
         //       执行时不等待 ，直接抢先执行。
        public HtThread extends Thread{
        private int i;
        public void run(){
            for(i=0;i<=100;i++){
                System.out.println("HtThread-->"+i);
            }
        }
        public HtRunnable implementsRunnable{
        private int i;
        public void run(){
            for(i=0;i<=100;i++){
                System.out.println("HtRunnable-->"+i);
            }
        }

        public static void main(String args[]){
            HtThread thread=new HtThread();
            HtRunnable runnable=new HtRunnable();
            thread.start();
            for(int i=0;i<=100;i++){
                System.out.println("test-->"+i);
            }
            //runnable.start();
        }

        Iterator<Sheep> iter=sheepList.iterator();
        int num=0;
        while(iter.hasNext()&&num<3){
            Sheep l=(Sheep)iter.next();
//      1.  if((l.name).equals("懒羊羊")){
//              iter.remove();
//          }
//      2.  if(sheepList.size()>2){
//              iter.remove();
//          }
//      3.  iter.remove();
//          num++;
        }
        for(int i=0;i<sheepList.size();i++)
        {
            //Sheep l=iter.next();
            System.out.println(((Sheep)(sheepList.get(i))).name);   
        }

        String[] filenames=manyfile.list();
        for(int i=0;i<filenames.length;i++){
            String path=filenames[i];
            file=new File(manyfile,filenames[i]);
            FileOutputStream oos=null;
            String s="我真"+i;
            try {
                oos=new FileOutputStream(file);
                try {
                    oos.write(s.getBytes());
                    //oos.write(i);
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

            } catch (FileNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }

public static void main(String[] args) {
        ThreadExtend h1=new ThreadExtend("一号");
        ThreadExtend h2=new ThreadExtend("二号");
        ThreadExtend h3=new ThreadExtend("三号");

        h1.start();
        h2.start();
        h3.start();//Thread

        Thread r1=new Thread(new ThredImp1());
        Thread r2=new Thread(new ThredImp1());
        Thread r3=new Thread(new ThredImp1());
        r1.start();//线程不能重复启动
        r2.start();
        r3.start();//runnable
    }

}
class ThredImp1 implements Runnable{
    public String name;

    public void run(){

        System.out.println(Thread.currentThread().getName());
    }
}
class ThreadExtend extends Thread{
    public ThreadExtend(String name){
        super(name);
    }
    public ThreadExtend(){
        super();
    }
    public void run(){
        for(int i=0;i<5;i++){
            System.out.println("我是"+this.getName()+i);
        }
    }
        //runnable和thread的区别：
        //.1.；避免单继承的局限性2.便于资源共享

        Iterator<String> sheepss = sheeps.iterator();
        int i = 0;
                方法一
         while (sheepss.hasNext()) {

         System.out.println(sheepss.next());
         i++;
         if (i > 2) break;
              }

        for(Iterator sheepss1 = sheeps.iterator();sheepss1.hasNext();){
            System.out.println(sheepss1.next());

        }
               方法二
        for (Object str : sheeps) {
        if (i < 3) {
            System.out.println(str.toString());
        }
        i++; 
           //i>3的时候删去前面的
        }

            方法三
          for(int i=0;i<sheeps.size();i++){ System.out.println(sheeps.get(i));

          } System.out.println("删除后三个");

         for(int i=0;i<sheeps.size()-3;i++){
          System.out.println(sheeps.get(i));

          } System.out.println("删除前两个"); 
             for(int  i=sheeps.size()-1;i>sheeps.size()-4;i--){
          System.out.println(sheeps.get(i));

          }


    }

     //Runnable 代码被多个线程共享；
    public void run() {
        while (num > 0) {
            num--;
            System.out.println(Thread.currentThread().getName() + "减少了一" + "  "
                    + num);
        }

    }
           MyThread a = new MyThread();
           Thread b = new Thread(a, "one");
           Thread c = new Thread(a, "two");
           Thread d = new Thread(a, "three");
             b.start();
             c.start();
             d.start();
    //Thread    JAVA单继承方式
       public void run() {
        while (num > 0) {
            num--;
            System.out.println(name + "减少了一" + "  " + num);

        }
    }
        Mythread a = new Mythread("first");
        Mythread b = new Mythread("second");
        Mythread c = new Mythread("third");
             a.start();
             b.start();
             c.start();

            for (int i = 0; i < 10; i++) {

                file = new File(manyfile, "helloworld" + i + ".txt");
                if (!file.exists()) {
                    file.createNewFile();

                }
            }
        for (int i = 0; i <= 9; i++) {
            file = new File(manyfile, "helloworld" + i + ".txt");
            OutputStream os = null;
            try {
                os = new FileOutputStream(file);
                String s = "我真" + i;

                try {
                    os.write(s.getBytes());
                } catch (NumberFormatException | IOException e) {
                    e.printStackTrace();
                }
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } finally {
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }

线程**********************************************
class A implements Runnable 
{   private String name ;
    private int Apple;
    public A(String name){
        this.name = name;
    }
    public void run(){
        for (Apple = 6;Apple >= 0 ;Apple-- )
        {
            System.out.println(name + "卖苹果："+Apple);
        }
    }
}
public class ceshi extends Thread       
{   
    private String name;
    private int ticket;
    public ceshi(String name){
        this.name = name;
    }
    public void run(){
        for (ticket = 5 ;ticket>= 0 ;ticket-- )
        {
            System.out.println(name+"卖票: "+ticket);

        }
    }

    public static void main(String[] args){
        ceshi c1 = new ceshi("A");      //资源不共享
        ceshi c2 = new ceshi("B");
        ceshi c3 = new ceshi("C");
        c1.start();             
        c2.start();
        c3.start();
        System.out.println("*************************");
        A C = new A("老王");  //资源达到共享
        new Thread(C).start();  
        new Thread(C).start();
        new Thread(C).start();
    }
}
*********************************************************、
删羊：   List<String> AllList = null;
        AllList = new ArrayList<String>();
        AllList.add("Hello1");
        AllList.add("Hello2");
        AllList.add("Hello3");
        AllList.add("Hello4");
        AllList.add("Hello5");
        System.out.println(AllList);
        //System.out.println(AllList.get(0));
        List<String>SubList = AllList.subList(2,4);//通过截取部分集合删除羊1
        for (int i = 0;i <SubList.size();i++){
            System.out.println(SubList.get(i)+" ");
        }
        for (int i = 0;i <AllList.size()-2;i++){        //删除羊2
            System.out.print(AllList.get(i+2)+" ");
        }
        System.out.println();
        for (int i = 0 ; i < 3; i++){               //删除羊3
        AllList.remove(i);
        }
        System.out.println(AllList);

***********************************************************************
写文件：
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
public class IOdemo
{
    public static void main(String[] args)throws Exception{
        File f = new File("e:"+File.separator+"text.txt");
        OutputStream out = new FileOutputStream(f);
        String st = "Hello world";
        byte b[] = st.getBytes();
        for (int i = 0;i<b.length ;i++ )
        {
            out.write(b[i]);
        }
        out.close();
    }
}

//方法1：从后往前
int len = sheepList.size();
for(int i = sheepList.size()-1; i >= len - 3; i--){
    sheepList.remove(i);
}
//方法2：删除固定位置
for(int i = len - 3; i < len; i++){
    sheepList.remove(len - 3);
}
//方法3：使用迭代器删除
int count = 0;
Iterator<Sheep> itr = sheepList.iterator();
while(itr.hasNext()){
    if(count >= len - 3){
        Object ed = itr.next();
        itr.remove();
    }else{
        itr.next();
        count++;
    }
}

File manyFiles = new File("G:\\AndroidStudioProjects\\testForIO");
File file;
OutputStream os = null;
try {
    for(int i = 0; i < 10; i++){
        file = new File(manyFiles, "helloworld" + i + ".txt");
        os = new FileOutputStream(file);
        String s = "我真" + i;
        os.write(s.getBytes());
    }
} catch (FileNotFoundException e) {
    e.printStackTrace();
}finally{
    try {
        os.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

/**
 * Thread是类，Runnable是接口
 * Runnable中没有start（）方法，只有Thread才有，可以通过Thread类来启动Runnable子类实例
 * 实现Runnable接口相比继承Thread类好处：1、避免继承的局限性，一个类可以有多个接口； 2、适合资源共享
 * @author LiPeijing
 *
 */
public class Actor extends Thread {
    public void run(){
        System.out.println(getName() + "是一个演员！");
        int count = 0;
        boolean keepRunning = true;
        while(keepRunning){
            System.out.println(getName() + "登台演出：" + (++count));
            if(count == 100){
                keepRunning = false;
            }
            if(count % 10 == 0){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                    }
            }
        }
        System.out.println(getName() + "的演出结束了！");
    }
    public static void main(String[] args){
        Thread actor = new Actor();
        actor.setName("Mr.Thread");
        actor.start();
        Thread actressThread = new Thread(new Actress(), "Ms.Runnable");
        actressThread.start();
    }
}
class Actress implements Runnable{
    @Override
    public void run() {
        // TODO Auto-generated method stub
        System.out.println(Thread.currentThread().getName() + "是一个演员！");
        int count = 0;
        boolean keepRunning = true;
        while(keepRunning){
            System.out.println(Thread.currentThread().getName() + "登台演出：" + (++count));
            if(count == 100){
                keepRunning = false;
            }
            if(count % 10 == 0){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
        System.out.println(Thread.currentThread().getName() + "的演出结束了！");
    }
}

方法1：
    for (int i = 1; i <=sheepList.size(); i++) {
        sheepList.remove(2);
        }
方法2：
    for(int i=sheepList.size()-1;i>1;i--){
        sheepList.remove(i);
        }
方法3：
        System.out.println(sheepList.subList(0, 2));
    for (int i = 0; i < sheepList.size(); i++) {
            System.out.println(sheepList.get(i));
        }
方法4：
       Iterator it=sheepList.iterator();
       while(it.hasNext()){
       Sheep sheepList1=(Sheep)it.next();
          if(sheepList1.getName()=="慢羊羊"||sheepList1.getName()=="沸羊羊"
               ||sheepList1.getName()=="懒羊羊"){
            it.remove();
            }
         }
方法5:
    int count=0;
    int len=sheepList.size();
    Iterator it=sheepList.iterator();
    while(it.hasNext()){
    if(count >= len - 3){
        Object ed=it.next();
        it.remove();
            }
        else{
            it.next();
            count++;
                      }
        }

for(int i=0;i<10;i++){
    File file3=new File(manyfile,"helloworld"+i+".txt");
    file=new File(manyfile,"helloworld"+i+".txt");
    OutputStream os=null;
       try {
        os=new FileOutputStream(file3);
        String s="我真"+i;
        try {
            os.write(s.getBytes());
            } catch (IOException e) {
                e.printStackTrace();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
        try{
            os.close();
            }catch(IOException e){
                e.printStackTrace();
            }
        }
}

public class FirstThread extends Thread {
        private int i; 
        public void run(){
            for(i=0;i<5;i++){
                System.out.println(getName()+" "+i);
            }
        }
        public static void main(String[] args) {
            for(int i=0;i<5;i++){
                System.out.println(Thread.currentThread().getName()+""+i);
                if(i==2){
                    new FirstThread().start();
                    new FirstThread().start();
                }
            }
        }
}
public class SecondThread implements Runnable {
    private int i;
    public void run() {
        for(i=0;i<5;i++){
            System.out.println(Thread.currentThread().getName()+""+i);
            if(i==2){
                SecondThread st=new SecondThread();
                new Thread(st,"新线程1").start();
                new Thread(st,"新线程2").start();
            }
        }
    }
}

  public static void main(String[] args) {
        System.out.println("hello git");
   }