关闭

JAVA基础核心,早年的总结,今天分享

标签: java杂谈
480人阅读 评论(0) 收藏 举报
分类:
获取时间:System.currnetTimeMillis();

系统默认不带缀的浮点数为double型,如5.1为double型,而float a=5.1是会报错的

‘\r‘表示 接受键盘的输入,相当于按下了回车键;相当于搜狗输入法按了空格键
‘\n‘是换行
byte b=2;b=b-1;这是错误的,因为表达式b-1在进行运算时,系统会自动把b的值提升为int型再和1相减,结果就是一个int型。

System.out.println(‘a’+1)   //输出98
System.out.println(“”+‘a’+1)   //输出a1



简单总结就是:成员函数,在多态调用时,编译看左边,运行看右边

Object类-equals()   实际是比较的对象引用的地址

当内部类中定义了静态成员,该内部类必须是static
        (2)、当外部类中的静态方法,访问内部类时,内部类也必须是 static

匿名颞部类中定义的方法最好不要超过3个

System.exit(0); 系统退出,jvm结束

每一个安卓程序对应一个 dex

主意    
            (1)、主意:finally中定义的通常是 关闭资源代码,因为资源必须释放
            (2)、finally只有一种情况不会执行,当执行到 System.exit(0);

创建线程-run和start特点
    1、为什么要覆盖 run 方法呢,thread 类用于描述线程
        (1)、该类就定义了一个功能,用于存储线程要运行的代码,该存储功能就是 run 方法
        (2)、也就是说 Thread 类中的 run 方法,用于存储线程要运行的代码     

/* 
需求:简单的卖票程序 
多个窗口卖票 
*/  
class Ticket extends Thread{  
    private static int tick = 100;  
    public void run(){  
        while(true){  
            if(tick>0){  
                System.out.println(Thread.currentThread().getName()+" sale:"+tick--);  
            }  
        }  
    }  
}  
public class Demo{  
    public static void main(String[] args){  
        Ticket t1 = new Ticket();  
        Ticket t2 = new Ticket();  
        Ticket t3 = new Ticket();  
        Ticket t4 = new Ticket();  
        t1.start();  
        t2.start();                         //这里的start调用的就是上面的run方法
        t3.start();  
        t4.start();  
    }  
}  


实现线程的两种方式

继承类 Thread

实现runnable接口

两种方式区别:
            [1]、继承 Thread:线程代码存放在 Thread 子类 run 方法中     new 本类,然后直接执行start方法
            [2]、实现 Runnable:线程代码存放在接口的子类的 run 方法中   new thread类  然后执行start方法

java对于多线程的安全,提供了专业解决方式:
        (1)、就是同步代码块
        (2)、synchronized(){}

ublic void run(){  
        while(true){  
            synchronized(obj){  
                if(tick>0){  
                    System.out.println(Thread.currentThread().getName()+" sale:"+tick--);  

class Bank{  
    private int sum;  
    Object obj = new Object();  
    public synchronized void add(int n){  
        sum = sum + n;  
        System.out.println("sunm = "+sum);  
    }  



/* 
需求:银行有一个金库 
有两个储户分别存300元,每次存100,存3次 
目的:改程序,是否有安全问题 
 
 
如何找问题: 
    1、明确哪些代码是多线程运行代码 
    2、明确共享数据 
    3、明确多线程运行代码中哪些语句是操作共享数据的 
*/  
class Bank{  
    private int sum;  
    Object obj = new Object();  
    public synchronized void add(int n){      // 加锁的时候就是在存入钱的时候加上锁就行了
        sum = sum + n;  
        System.out.println("sunm = "+sum);  
    }  
}  
class Cus implements Runnable{  
    private Bank b = new Bank();  
    public void run(){  
        for(int x=0;x<3;x++){  
            b.add(100);  
        }  
    }  
}  
public class Demo{  
    public static void main(String[] args){  
        Cus c = new Cus();  
        Thread c0 = new Thread(c);  
        Thread c1 = new Thread(c);  
        c0.start();  
        c1.start();  
    }  
}  

public class Demo{  
    public static void main(String[] args){  
        String s1 = "abc";//s1是一个类类型变量,“abc”是一个对象。字符串最大特点:一旦被初始化,就不可以被改变  
        s1 = "kk";//字符串 abc 未改变,改变的是 s1的指向  
        String s2 = new String("abc");  
        System.out.println(s1==s2);//false  
        System.out.println(s1.equals(s2));//true   
        /*String类,复写了Object类中equals方法,该方法用于判断字符串是否相同 
        s1代表一个对象 
        s2代表两个对象 
        */  
    }  
}  

根据位置获取位置上的某个字符    
            int indexOf(int ch):返回的是ch字符第一次出现的位置
            int indexOf(int ch,int fromIndex):从fromIndex指定位置开始,获取str在字符串中的出现的位置            
            int indexOf(String str):返回的是字符串在总字符串中第一次出现的位置
            int indexOf(String str,int fromIndex):从fromIndex指定位置开始,获取str在字符串中的出现的位置

判断内容是否相同,并忽略大小写
            boolean equalsIgnoreCase(str);

替换
        String replace(char oldChar,char newChar)

切割
        String[] split(String str)  

String substring(int beginIndex, int endIndex) //包含头,不包含尾部 返回新字符串,是大字符串的子字符串

将字符串转成大写或者小写
        (1)、String toUpperCase();
        (2)、String toLowerCase();     trim()
对两个字符串进行自然顺序的比较
        (1)、int compareTo(String);



StringBuffer(常见功能-添加)
        (1)、字符串的组成原理就是通过该类实现的。
        (2)、StringBuffer可以对字符串内容进行增删
        (3)、StringBuffer是一个容器
        (4)、很多方法与String相同
        (5)、StringBuffer是可变长度的

存储
            StringBuffer append():将指定数据作为参数添加到已有数据结尾处
            StringBuffer insert(index,数据):可以将数据插入到指定位置上去
        (2)、删除
            StringBuffer delete(start,end):删除缓冲区中的数据,包含start,不包含end
            StringBuffer deleteCharAt(index):删除指定位置的字符
            sb.delete(0,sb.length());  清空缓冲区,删除全部
            sb.delete(2,3);  删除一个字符,应该用 sb.deleteCharAt(2);
        (3)、获取
            char charAt(int index)
            int indexOf(String str)
            int lastIndexOf(String str)
            int length()
            String substring(int start,int end)  注意,返回的是string,不是StringBuffer
        (4)、修改
            StringBuffer replace(start,end,string);
            StringBuffer reverse()  
            void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 
          将字符从此序列复制到目标字符数组 dst。 

StringBuffer 是线程同步  多线程也可以,自身有判断锁,但是效率低
        (2)、StringBuilder 是线程不同步  不是多线程的,不用判断锁,所以单线程都用这个

fw.flush();  
        //关闭刘子源,但是关闭之前会刷新一次内部的缓冲的数据。,将数据刷到目的地中,和flush区别,flush(),刷新后,流可以继续使用,close刷新后,会将流关闭。  
        //操作完,必须关闭  
        fw.close();  

FileWriter fw = null;  
        try{  
            //为true表示不覆盖已有文件,并且续写  
            fw = new FileWriter("Demo.txt",true);  

import java.io.*;  
class Demo{  
    public static void main(String args[]) throws Exception{           // io流 读取后写入的方式
字符流的缓冲区

    1、缓冲区的出现提高了对数据的读写效率
    2、对应类
        (1)、BufferdWriter
        (2)、BufferdReader
    3、缓冲区要结合流才可以使用
    4、在流的基础上对流的功能进行了增强
    5、  
        void close()  关闭此流,但要先刷新它。 
        void flush() 刷新该流的缓冲 
        void newLine() 写入一个行分隔符。 跨平台

FileReader fr = new FileReader("Demo.txt"); //定义一个字符串数组,用于存储到的字符 //该 read(char[])返回的是读到的字符个数 char[] buf = new char[1024]; int num = 0; while((num = fr.read(buf))!=-1){ System.out.println(num+"..."+new String(buf,0,num)); // 注意这里最后的打印方式 } }

 while((line = bufr.readLine())!=null){  
                bufw.write(line);  
                bufw.flush();  
                bufw.newLine();//必须写  

O流(readLine的原理图例)
    readLine()方法原理
    不论是读一行,获取多个字符,其实最终都是在硬盘上一个一个读取,所以最终使用的还是 read() 方法一次读一个的方法
   
都是一个一个读取的所以,读取的时候读一个执行一次,不如读1024个在执行一次

IO流(MyBufferedReader)
    明白了 BufferedRead 类中特有方法 readLine 的原理后,
    可以自定义一个类中包含一个功能和readLine一致的方法
    来模拟一下BufferedReadLine
[java] view plaincopy
/* 
    通过缓冲区复制一个 .java 文件 
*/  
import java.io.*;  
class Demo{  
    public static void main(String args[]) throws IOException{  
        FileReader fr = new FileReader("Demo.java");  
        MyBufferedReader myBuf = new MyBufferedReader(fr);  
        String line = null;  
        while((line=myBuf.myReadLine())!=null){  
            System.out.println(line);  
        }  
        myBuf.myClose();  
    }  
}   
class MyBufferedReader{  
    private FileReader fr;  
    MyBufferedReader(FileReader fr){  
        this.fr = fr;  
    }  
    //可以一次读一行数据的方法  
    public String myReadLine() throws IOException{  
        //定义一个临时容器,原BufferedReader封装的是字符数组  
        //为了方便,定义一个StringBuilder容器,因为最终还是要将数据变成字符串  
        StringBuilder sb = new StringBuilder();  
        int ch = 0;  
        while((ch=fr.read())!=-1){  
            if(ch=='\r')  
                continue;  
            if(ch=='\n')  
                return sb.toString();  
            else  
            sb.append((char)ch);  
        }  
        //防止最后一行没有换行的情况  
        if(sb.length()!=0){  
            return sb.toString();  
        }else{  
            return null;  
        }  
    }  
    public void myClose() throws IOException{  
        fr.close();  
    }  
}  



六、IO流(装饰设计模式)
    1、当想要对已有对象进行功能增强时,可以定义一个类,将已有对象传入,基于已有的功能,并提供加强功能,那么该自定义类称为装饰类
    2、装饰类通常会通过构造方法接收被装饰的对象。并基于被装饰的功能,提供更强的功能。
    
七、IO流(装饰和继承的区别)
八、IO流(自定义装饰类)
九、IO流(LineNumberReader)
跟踪行号的缓冲字符输入流。此类定义了方法 setLineNumber(int) 和 getLineNumber(),它们可分别用于设置和获取当前行号。
[java] view plaincopy
import java.io.*;  
class Demo{  
    public static void main(String args[]) throws IOException{  
/**
 * 非常简便的加行标类
 * 
 * @author GreaterMan
 * 
 */
public class MoreIo
{
	public static void main(String[] args) throws IOException
		{
		FileReader fr = new FileReader("D:\\text\\Example05.java");
		LineNumberReader lnr = new LineNumberReader(fr);
		String line = null;
		lnr.setLineNumber(0);
		while ((line = lnr.readLine()) != null)
			{
			System.out.println(lnr.getLineNumber() + ":" + line); //自动换行,而且自增行数
			}
		lnr.close();
		}

}

FileReader fr = new FileReader("Demo.java"); LineNumberReader lnr = new LineNumberReader(fr); String line = null; lnr.setLineNumber(2); while((line=lnr.readLine())!=null){ System.out.println(lnr.getLineNumber()+":"+line); } lnr.close(); } }

需求:想要操作图片数据。据悉要到字节流

inputStream outputStream

FileReader fr = new FileReader("Demo.java"); 
LineNumberReader lnr = new LineNumberReader(fr); 
String line = null; lnr.setLineNumber(2); 
while((line=lnr.readLine())!=null)
 	{ 
	System.out.println(lnr.getLineNumber()+":"+line); 
	}
 lnr.close(); 
    }
 }

需求:想要操作图片数据。据悉要到字节流
inputStream outputStream
/* 
需求,通过键盘录入数据。  									高效率的输入输出流操作
OutputStream out = System.out;  

OutputStream out = System.out;  

当录入一行数据后,就将改行数据进行打印,如果录入数据是over,那么停止录入 */ 
import java.io.*;
public class Demo{ 
public static void main(String args[]) throws IOException{//获取键盘录入对象 
InputStream in = System.in; //将字节流对象转换成字符流对象,使用转换流,
InputStreamReader InputStreamReader isr = new InputStreamReader(in); //为了提高效率,将字符进行缓冲区技术高效操作,使用bufferedReader 
BufferedReader bufr = new BufferedReader(isr); 
String line = null; 
while((line = bufr.readLine())!=null)
	{
 	if(line.equals("over"))
		{
 		break; 
		} 
System.out.println(line.toUpperCase()); 
	} 
bufr.close(); 
    } 
}
//BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));              对应键盘      FileOutputStream  

//BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));    

BufferedReader bufr = new BufferedReader(new FileReader("a.txt"));                          对应硬盘

BufferedWriter bufw = new BufferedWriter(new FileWriter("b.txt"))                           file针对的是文件

BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("d.txt"),"UTF-8"));  对应编码  字符流里面用字节流
目的:OutputStream Writer
            是否是纯文本?是,Writer                                                         对应编码
            是不是设备?是,硬盘,使用,FileWriter                                           FileOutputStream 可指定文件编码
           
            但是存储是,需要加入指定的编码表,而制定的编码表,只有转换流可以指定。
            所以要使用的对象是 OutputStreamWriter.
            而该转换流对象要接收一个字节输出流。而且还可以操作文件的字节输出流,FileOutputStream
            
            OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("d.txt"),"UTF-8");
            
            需要高效吗?需要
            BufferedWriter bufw = new BufferedWriter(osw);

File.separator 转义字符"\"

File类的操作
创建
    boolean createNewFile():在指定位置创建文件,如果该文件已经存在,则不创建,返回false
        和输出流不一样棒,输出流对象一建立就创建文件,而且文件已经存在,会覆盖
    boolean mkdir() 创建此抽象路径名指定的目录。 
    2、删除
    boolean delete() 删除此抽象路径名表示的文件或目录。
    void deleteOnExit() 在虚拟机终止时,请求删除此抽象路径名表示的文件或目录。 
        当被操作时候,删除不了,所以等虚拟机终止时,删除





   
0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:62373次
    • 积分:1071
    • 等级:
    • 排名:千里之外
    • 原创:46篇
    • 转载:21篇
    • 译文:0篇
    • 评论:0条