[学习交流] 黑马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;
}
}

帐号		自动登录	找回密码
密码			加入黑马

[学习交流] 黑马java基础练习

0 个回复