黑马程序员技术交流社区

标题: 黑马java基础练习 [打印本页]

---

作者: 孙月华    时间: 2016-11-22 20:19
标题: 黑马java基础练习
java自学
目录：
自定义MylineNumberReader类的两种。        1
读写转换流的使用        3
改变标准的输入输出流设备        4
线程        4
线程间通讯1        6
线程间通讯2  代码优化        8
死锁线程1        9
死锁线程2        10
中断线程        11
ListIterator的运用        14
LinkedList练习 堆栈 列表        16
ArrayList练习        17
ArrayList练习2        18
HashSet        20
HashSet存储自定义类型13—14节        21
TreeSet 存储自定义对象        22

自定义MylineNumberReader类的两种。
import java.io.*;
public class pracice5 {
public static void main(String[]arr)throws IOException
{
        //此处还不存在该文件，
        MyLineNumberReader fw=new MyLineNumberReader(new FileReader("pracice5.txt"));
   String ss=null;
   while((ss=fw.MylineRead())!=null){
           System.out.println(ss);
   }
   fw.Myclose();
}
}
///////
/*class MyLineNumberReader{
        private Reader r;
        private int linenumber;
        MyLineNumberReader(Reader r){
                this.r=r;
        }
        public String MyreadLine()throws IOException
        {
                StringBuilder sb=new StringBuilder();
                linenumber++;
                int ch=0;
                while((ch=r.read())!=-1){
                        if(ch=='\r')
                                continue;
                        else if(ch=='\n')
                                return sb.toString();
                        else
                        sb.append((char)ch);       
                }
                if(sb.length()!=0)
                        return sb.toString();
                return null;
        }
        public void setlinenumber(int a){
                linenumber=a;
        }
public void Myclose()throws IOException
{
        r.close();
}
public int getlinenumber(){
        return linenumber;
}
}
*/
//////
class MyLineNumberReader extends BufferedReader{
        private int linenumber;
        private Reader r;
        MyLineNumberReader(Reader r){
                super(r);
        }
        public String MylineRead()throws IOException
        {
                linenumber++;
                return super.readLine();
        }
        public void setlinenumber(int a){
                linenumber=a;
        }
        public int getlinenumber(){
                return linenumber;
        }
        public void Myclose()throws IOException
        {
        r.close();       
        }
}


读写转换流的使用
import java.io.*;
public class pracice5 {
public static void main(String[]arr)throws IOException
{
        //读取转化流
        InputStream in=System.in;
        InputStreamReader irr=new InputStreamReader(in);
        BufferedReader fw=new BufferedReader(irr);
        BufferedWriter fs=new BufferedWriter(new OutputStreamWriter(System.out));
        String line=null;
        while((line=fw.readLine())!=null){
                if("over".equals(line))
                        break;
                fs.write(line.toUpperCase());
                //注意此处写刷新和不写刷新的输出区别。
                fs.flush();
        }
        fw.close();
        fs.close();
       
}
}



改变标准的输入输出流设备
import java.io.*;
public class pracice5 {
public static void main(String[]arr)throws IOException
{
        System.setIn(new FileInputStream("practice3.txt"));
        System.setOut(new PrintStream("practice3_01.txt"));
        BufferedReader fi=new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter fr=new BufferedWriter(new OutputStreamWriter(System.out));
        String sb=null;
        while((sb=fi.readLine())!=null){
                if("over".equals(sb))
           break;
                fr.write(sb.toUpperCase());
                fr.newLine();
                fr.flush();
        }
        fr.close();
        fi.close();
}
}



线程

public class practice6{
public static void main(String [] args){
        ticket a1=new ticket();
        Thread b1=new Thread(a1);
        Thread b2=new Thread(a1);
    b1.start();
    try{
            Thread.sleep(10);
    }
    catch(Exception e){}
    a1.b=false;
   b2.start();
    //可能b2刚开启，还没执行，后面两句就执行了，所以让主线程睡一下
       
}
}
class ticket implements Runnable
{
        private static int NUM=1000;
        boolean b=true;
       
        public  void run(){
                while(true){
                if(b){
                        //为了满足前提：使用同一个锁，所以这里也用this，不然，会输出0票。
                        synchronized(ticket.class){
                if(NUM>0){
                       
                        System.out.println(Thread.currentThread().getName()+"on sale"+NUM--);
                }
                }
                }
                else
                while(true){
                        //这里使用show()也是对的。
                        this.show();
                }
                }
        }
        //show()的锁是this
                public static synchronized void show(){
                        if(NUM>0){
                               
                                System.out.println(Thread.currentThread().getName()+"in sale"+NUM--);
                        }
                }
        }



线程间通讯1
public class practice4{
public static void main(String [] args){
        Res a1=new Res();
        Input b1=new Input(a1);
        Output b2=new Output(a1);
        Thread c1=new Thread(b1);
        Thread c2=new Thread(b2);
        c1.start();
        c2.start();
}
}
class Res{
        String name;
        int age;
        boolean flag=false;
}
class Input implements Runnable{
        private Res a;
        Input(Res b){
                this.a=b;
        }
        public void run(){
        int x=0;
                while(true){
                        synchronized(a){
                                if(a.flag)
                                        try{
                                                a.wait();
                                        }
                                catch(Exception e){}
                        if(x==0){
                                /*保证第二个前提，用this??
                                 * 不行。
                                 * 因为这里的this指Input对象，和下面Output中的this不同
                                 * 从而不满足前提而
                                 */
                  
                a.name="huazai";
                a.age=20;
                        
                        }
                        else{
                                //虽然在两个run方法里面，但是都在处理同一个资源
                           
                                a.name="丽娟";
                                a.age=16;
                                 }
                       
                   x=(x+1)%2;
                   a.flag=true;
                  a. notify();
        }
                }
        }
}
class Output implements Runnable{
        /*
         * Output和Input中为啥不单独直接定义一个Res 而要通过构造函数？？
         * 注意主函数中，为了使其操作同一个对象，满足操作同一资源，
         */
        private Res a;
        Output(Res b){
                this.a=b;
        }
        public void run(){
        while(true){
synchronized(a){
        if(!a.flag)
                try {
                        a.wait();
                } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
        System.out.println(a.name+"……"+a.age);
        a.flag=false;
        a.notify();
        }
      }
}
}


线程间通讯2  代码优化
public class practice7{
public static void main(String [] args){
        Res t=new Res();
        new Thread(new Input(t)).start();
        new Thread(new Output(t)).start();
       
}
}
class Res{
        private String name;
        private int age;
        private boolean flag=false;
        public synchronized void setname(String name,int age){
                if(flag)
                        try{wait();}catch(Exception e){}
                        this.name=name;
                        this.age=age;
                        flag=true;
                this.notify();
        }
        public synchronized void outname(){
                if(!flag)
                        try{this.wait();}catch(InterruptedException e){}
                System.out.println(name+"....."+age);
                flag=false;
                this.notify();
        }
}
class Input implements Runnable{
        Res r;
        Input(Res r){
                this.r=r;
        }
        public void run(){
                int x=0;
                while(true){
                if(x==0)
        r.setname("孙月华",20);
                else
                        r.setname("丽娟",16);
                x=(x+1)%2;
        }
}
}
class Output implements Runnable{
        Res r;
        Output(Res r){
                this.r=r;
        }
        public void run(){
                while(true)
        r.outname();
}
}






死锁线程1

public class practice7 {
public static void main(String[]arr){
        tic t=new tic();
        Thread a1=new Thread(t);
        Thread a2=new Thread(t);
        a1.start();
        a2.start();
}
}
class tic implements Runnable
{
        private  int ticketNum=1000;
        private boolean flag=true;
        public void run(){
        while(true){
                if(flag){
                        synchronized(new Object()){
                                show();
                                }
                        }       
                else
                        while(true)
                        this.show();
        }
        }

        public synchronized void show(){
                synchronized(new Object()){
                        if(ticketNum>0){
                                System.out.println(Thread.currentThread().getName()+ticketNum--);
                        }
                }
        }
}
死锁线程2

public class practice7 {
public static void main(String[]arr){
Thread a1=new Thread(new Test(true));
Thread a2=new Thread(new Test(false));
a1.start();
a2.start();
}
}
class Test implements Runnable{
        private boolean flag;
        public Test(boolean a){
                this.flag=a;
        }
        public void run(){
                if(flag){
                        synchronized(Mylock.a1){
                                System.out.println("这是外层锁");
                                try{
                                        Thread.sleep(20);
                                }
                                catch(InterruptedException e){
                                        e.printStackTrace();
                                }
                                synchronized(Mylock.a2){
                                        System.out.println("这是内层锁");
                                }
                        }
                }
                else
                        synchronized(Mylock.a2){
                                System.out.println("这是外层锁");
                                synchronized(Mylock.a1){
                                        System.out.println("这是内层锁");
                                }
                        }
        }
}
class Mylock{
        static Object a1=new Object();
        static Object a2=new Object();
}



中断线程
public class practice7{
public static void main(String [] args){
        StopThread r=new StopThread();
        Thread b1=new Thread(r);
        Thread b2=new Thread(r);
        b1.start();
        b2.start();
        int num=0;
        while(true){
                if(num++==60){
                        //r.changestate();
                        b1.interrupt();
                        b2.interrupt();
                break;
                }
                System.out.println(Thread.currentThread().getName()+"........main");
        }
        System.out.println("main...over");
}
}
class StopThread implements Runnable
{
        private boolean flag=true;
        public synchronized void run(){
        while(true){
                try{
                        wait();
                }
                catch(InterruptedException e){
                        System.out.println(Thread.currentThread().getName()+"....Exception");
                        flag=false;
                }
                System.out.println(Thread.currentThread().getName()+"....run");
        }
        }
        /*public void changestate(){
                flag=false;
        }
        */
       
}


14—02—03迭代器等
import java.util.*;
public class practice7{
public static void main(String [] args){
        menth_get();
}
public static void sop(Object obj){
        System.out.println(obj);
}
public static void menth_get(){
        //取出元素，并操作元素，而不是简单的打印
        //而是获取后要进行某些操作
        /*ArrayList a1=new ArrayList();
        a1.add("java01");
        a1.add("java02");
        a1.add("java03");
        a1.add("java04");
        a1.add("java05");
        sop(a1);
        什么是迭代器：其实就是集合元素的取出方式
        */
        ArrayList a1=new ArrayList();
        a1.add("java01");
        a1.add("java02");
        a1.add("java03");
        a1.add("java04");
        a1.add("java05");
        Iterator it=a1.iterator();//获取迭代器，用于取出集合中的元素
        /*while(it.hasNext()){
        sop(it.next());
        sop(it.next());
        }*/
        //使用for的好处，利于内存。。
        //使用for it1就只是一个局部变量，for结束后就消失
        for(Iterator it1=a1.iterator();it1.hasNext();){
                sop(it1.next());
        }
}
public static void menth2(){
        ArrayList a1=new ArrayList();
        a1.add("java01");
        a1.add("java02");
        a1.add("java03");
        a1.add("java04");
        a1.add("java05");
       
        ArrayList a11=new ArrayList();
        a11.add("java01");
        a11.add("java02");
        a11.add("java05");
        a11.add("java06");
        a11.add("java07");
       
        a11.retainAll(a1);//取交集 a11中只会保存和a1相同的元素。
        //a11.removeAll(a1);
        sop("a1"+a1);
        sop("a11"+a11);
}
public static void base_menth(){
        ArrayList a1=new ArrayList();
        a1.add("java01");
        a1.add("java02");
        a1.add("java03");
        a1.add("java04");
        a1.add("java05");
        //集合元素打印
        practice7.sop("原集合"+a1);
        //集合内元素统计
        practice7.sop("size"+a1.size());
        //删除元素
        a1.remove("java02");
        //在此打印
        sop(a1);
        //清空集合
        a1.clear();
        //判断元素
        sop("java03是否存在"+a1.contains("java03"));
        //集合是否为空
        sop("集合是否为空"+a1.isEmpty());
}
}



ListIterator的运用
import java.util.*;
public class practice7{
        public static void sop(Object obj){
                System.out.println(obj);
        }
        public static void menth(){
                ArrayList a1=new ArrayList();
                a1.add("java01");
                a1.add("java02");
                a1.add("java03");
                a1.add("java04");
                //使用特有方法，在指定位置添加元素。
                sop("原集合"+a1);
                //在指定位子添加元素
                a1.add(1,"java05");
                sop(a1);
                //删除指定位置的元素
                a1.remove(2);
                sop(a1);
                //修改元素
                a1.set(2,"sunyuehua");
                //查元素，通过角标获取元素
                sop("get(1)"+a1.get(1));
                //获取所有元素  for循环遍历
                for(int x=0;x<a1.size();x++){
                        System.out.println("a1.get(x)"+a1.get(x));
                }
                Iterator it=a1.iterator();
                while(it.hasNext()){
                        sop("next"+it.next());
                }
                //通过indexOf获取对象的位置
                sop("index获取："+a1.indexOf("java01"));
                List sub=a1.subList(1,3);
                sop(sub);
        }
public static void main(String [] args){
        //演示列表迭代器
        ArrayList a1=new ArrayList();
        a1.add("java01");
        a1.add("java02");
        a1.add("java03");
        a1.add("java04");
        //元素的引用装到了迭代器中
        //此时有两种操作元素的方式   1 集合 2 迭代器
        sop(a1);
        /*
        Iterator it=a1.iterator();
        while(it.hasNext()){
                /*一下会出错，  只可以要么用迭代器操作要么用集合操作
                 * 迭代器中只有三个方法 判断  取出 移除
                 * Object obj=it.next();
                if(obj.equals("java01"))
                a1.add("java08");
                //sop("next"+it.next());
                 
                 Object obj=it.next();
                        if(obj.equals("java01"))
                        it.remove();
                        //移除的知识对象引用，而对象本身还在内存中
                        //移除javao1后  obj仍在用它，所以可以打印
                sop("obj:  "+obj);
                sop(a1);
        }*/

ListIterator it=a1.listIterator();
//sop("it.hasPrevious :"+it.hasPrevious());
while(it.hasNext()){
        Object obj=it.next();
        if(obj.equals("java01"))
                //it.add("java08");
                it.set("java00");
}

//sop("it.hasPrevious :"+it.hasPrevious());
//sop("it.hasNext :"+it.hasNext());
while(it.hasPrevious()){
        sop("Previous"+it.previous());
}

        sop(a1);
        //需求，在迭代过程中 添加或删除元素。。对集合中的元素进行取操作
}
}


LinkedList练习 堆栈 列表
import java.util.*;
public class practice7{
       
public static void main(String [] args){
        Duilie d1=new Duilie();
        d1.Myadd("java01");
        d1.Myadd("java02");
        d1.Myadd("java03");
        d1.Myadd("java04");
        while(!d1.isEmpty()){
        System.out.println(d1.Myget());
        }
}
}
//
class Duilie{
        private LinkedList link;
        Duilie(){
                link=new LinkedList();
        }
       
        public void Myadd(Object obj){
                link.addFirst(obj);
        }
       
        public Object Myget(){
                //先进后出
                return link.removeFirst();
                //return link.removeLast();
        }
        public boolean isEmpty(){
                return link.isEmpty();
        }
}



ArrayList练习
//让元素只唯一的存在于ArrayList中
import java.util.*;
public class practice7{
       
public static void main(String [] args){
ArrayList a1=new ArrayList();
a1.add("java01");
a1.add("java01");
a1.add("java02");
a1.add("java02");
a1.add("java04");

sop("原集合"+a1);
a1=singleElement(a1);
sop(a1);

}
public static ArrayList singleElement(ArrayList a1){
        //定义一个临时容器
        ArrayList newlist=new ArrayList();
        Iterator it=a1.iterator();
        while(it.hasNext()){
                Object obj=it.next();
                if(!newlist.contains(obj))
                newlist.add(obj);
        }
        return newlist;
}
public static void sop(Object obj){
        System.out.println(obj);
}
}



ArrayList练习2

存储自定义的对象，并进行一些操作
import java.util.*;
public class practice7{
       
public static void main(String [] args){
        ArrayList a1=new ArrayList();
        a1.add(new Person("lisi01",35));
        a1.add(new Person("lisi02",31));
        a1.add(new Person("lisi03",32));
        a1.add(new Person("lisi03",32));
        a1.add(new Person("lisi04",32));
        a1.add(new Person("lisi05",32));
        //Iterator it=a1.iterator();
        //此比较方法不可行，，因为比较的是对象  而没有安装我们需要的比较。
        //要复写equals方法  
        a1=SingleElement(a1);
        Iterator it=a1.iterator();
        while(it.hasNext()){
                //Object obj=it.next();
                //Person p=(Person)obj;
                Person p=(Person)it.next();
                sop(p.Getname()+"....."+p.Getage());
        }
        //删除一个元素
        //如果不在Person中复写equals方法，则移除不掉想要移除的元素，
        sop("remove 04"+a1.remove(new Person("lisi04",32)));
        //删除后再次打印集合
        Iterator it2=a1.iterator();
        while(it2.hasNext()){
                //Object obj=it.next();
                //Person p=(Person)obj;
                Person p=(Person)it2.next();
                sop(p.Getname()+"....."+p.Getage());
        }
       

}
        public static ArrayList SingleElement(ArrayList a1){
                //定义一个临时容器
                ArrayList newlist=new ArrayList();
                Iterator it=a1.iterator();
                while(it.hasNext()){
                        Object obj=it.next();
                        if(!newlist.contains(obj))
                        newlist.add(obj);
                }
                return newlist;
        }

       
public static void sop(Object obj){
        System.out.println(obj);
}
}

class Person{
        String name;
        int age;
        Person(String name,int age){
                this.name=name;
                this.age=age;
        }
        public String Getname(){
                return name;
        }
        public int Getage(){
                return age;
        }
        //此方法在底层被自动调用。contains的底层原理就是equals
        public boolean equals(Object obj){
                if(!(obj instanceof Person))
                        return false;
                Person p=(Person)obj;
                return this.name.equals(p.name)&&this.age==p.age;
        }
}



HashSet

import java.util.*;
public class practice7{
       
public static void main(String [] args){
        HashSet hs=new HashSet();
        hs.add("java01");
        //元素相同，只会输出一个。
        hs.add("java01");
        //判断存储是否成功
        sop(hs.add("java01"));
        sop(hs.add("java01"));
        hs.add("java02");
        hs.add("java03");
        hs.add("java04");
        Iterator it=hs.iterator();
        while(it.hasNext()){
                sop(it.next());
        }
       
}
public static void sop(Object obj){
        System.out.println(obj);
}
}



HashSet存储自定义类型13—14节
import java.util.*;
public class practice7{
       
public static void main(String [] args){
        HashSet hs=new HashSet();
        hs.add(new Person("a1",11));
        //hs.add(new Person("a1",11));
        hs.add(new Person("a1",12));
        hs.add(new Person("a1",13));
        hs.add(new Person("a1",14));
        //此代码中输出了两次 a1 11  .
        //要按自己的方法设置哈希值才可。
        Iterator it=hs.iterator();
        while(it.hasNext()){
                Person p=(Person)it.next();
                sop(p.name+"::"+p.age);
        }
        //此处调用equals
        sop("a1"+hs.contains(new Person("a1",11)));
       
        sop(hs.remove(new Person("a1",14)));
}
public static void sop(Object obj){
        System.out.println(obj);
}

}


class Person{
        String name;
        int age;
        Person(String name,int age){
                this.name=name;
                this.age=age;
        }
        public String Getname(){
                return name;
        }
        public int Getage(){
                return age;
        }
        public  int  hashCode(){
                //return 60;//不靠谱//此时会调用equals
                //一般按照条件设置哈希值
                System.out.println(name+"...hashCode");
                return name.hashCode()+age;//当元素重复时调用equals方法
        }
        //此方法在底层被自动调用。contains的底层原理就是equals
        public boolean equals(Object obj){
                if(!(obj instanceof Person))
                        return false;
                Person p=(Person)obj;
                //如果输出此内容，则证明equals被调用
                //在此代码中没有被调用。 因为哈希值不同
                System.out.println(this.name+"::equals:"+p.name);
                return this.name.equals(p.name)&&this.age==p.age;
        }
}

---

欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2