初学Java总结（三）

最新推荐文章于 2021-08-02 07:45:20 发布

MAC_RO

最新推荐文章于 2021-08-02 07:45:20 发布

阅读量159

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/MAC_RO/article/details/97814693

版权

Java 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

File

import java.io.File;
import java.io.IOException;

public class FileDemo1 {
	
	public static void main(String[] args) throws IOException {
		//创建File类对象
		//在创建对象过程中不会去检测真实的路径
		//只是在根据给定的路径创建对象
		File file=new File("D:\\a.txt");//此时未在该目录下创建真实的文件
		//重命名---剪切（路径不一样）
		file.renameTo(new File("D:\\javase\\2.txt"));//文件存储的路径
		//创建文件---空文件
		//boolean b=file.createNewFile();
		//创建文件夹---目录
		//不仅可以创建文件夹或者目录还可以创建多级目录
		//boolean b=file.mkdirs();
		//可以删除文件（有无内容），删除空目录
		//直接删除---不会放在回收中
		boolean b=file.delete();
		System.out.println(b);//删除成功返回true
		//返回目录或者文件的名称
		System.out.println(file.getName());
		//返回所在目录路径
		System.out.println(file.getParent());
		//返回所在位置的路径以及名称
		System.out.println(file.getPath());
	}
}

public class FileDemo2 {
	
	public static void main(String[] args) {
		//创建文件类对象
		File file=new File("D:\\");
		//获取当前目录下的所有文件以及文件夹的信息
		File[] fs=file.listFiles();
		//遍历数组
		for (File f : fs) {
			System.out.println(f);
		}	
		//判断是否是文件
		System.out.println(file.isFile());
		//判断是否是文件夹---目录
		System.out.println(file.isDirectory());
	}
}

删除文件

public class FileText1 {
	public static void main(String[] args) {
		//获取文件类对象
		File file=new File("D:\\a");
		//调用方法
		deleFile(file);
	}
	
	//删除文件
	public static void deleFile(File file){
		//判断是否是文件夹
		if(file.isDirectory()){
			//获取当前文件夹下所有的信息
			File[] fs=file.listFiles();
			//遍历数组
			for (File f : fs) {
				//把数组里的每一个文件类对象再次传入到本方法中
				deleFile(f);
			}
		}
		//删除文件---删除空目录
		file.delete();
	}
}

IO流

四大基本流
FileWriter fw=new FileWriter(“D:\1.txt”);
fw.write(“hahahaahhaha”);//开发时需要处理异常
fw.flush();//冲刷缓冲区
fw.close();
//强制对象值为null
//把对象置为无用对象，在某个时间进行垃圾回收
fw=null;
FileReader reader=new FileReader(“D:\2.txt”);
//读取数据
//返回的是读取到字符的编码值
//读取结束的标志就是返回-1
System.out.println((char)reader.read());
int len=-1;//提供变量供给读取数据覆盖
while((len=reader.read())!=-1){//避免读取两次情况
System.out.println(len);
}
//关流—输入流没有缓冲区
reader.close();
自建缓冲区

char[] cs=new char[3];
		int len=-1;
		//reader.read(字符数组)--返回值就是每次读取到的字符个数
		while((len=reader.read(cs))!=-1){//读取到的内容存放到数组
			System.out.println(new String(cs,0,len));
		}

利用文件流进行文件复制

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		long start=System.currentTimeMillis();
		FileReader reader=new FileReader("D:\\b.txt");//文件不存在会报错
		FileWriter writer=new FileWriter("D:\\a.txt");//文件不存在会新建
		char[] c=new char[1024*64];//自建缓冲区
		int count=-1;
		while((count=reader.read(c))!=-1){
			writer.write(c);
			writer.flush();
		}
		reader.close();
		writer.close();
		reader=null;
		writer=null;
		long end=System.currentTimeMillis();
		System.out.println(end-start);
	}
}

字节流

//创建字节输出流对象---没有缓冲区  true表明文件可追加,即不删除原有信息
		FileOutputStream os=new FileOutputStream("D:\\c.txt",true);
		//写出数据
		os.write("中".getBytes());//获取字节数组

FileInputStream fis=new FileInputStream("D:\\1.txt");
		//读取数据  结束标志是-1
		//System.out.println(is.read());
		//自建缓冲区
		byte[] bs=new byte[10];
		int len=-1;
		while((len=fis.read(bs))!=-1){
			System.out.println(new String(bs,0,len));
		}

BufferedReader

BufferedReader br=new BufferedReader(new FileReader("D:\\a123.txt"));
		//读取一行---结束标志null
		String str="";
		while((str=br.readLine())!=null){
			System.out.println(str);
		}

BufferedWriter bw=new BufferedWriter(new FileWriter("D:\\b.txt"));
		//写出数据
		bw.write("abc");
		bw.newLine();//换行---不管具体什么的操作系统
		bw.write("123");

合并流

public class SequenceInputStreamDemo {
	
	public static void main(String[] args) throws IOException {
		//提供输入流---提供待合并的数据
		FileInputStream in1=new FileInputStream("D:\\a1.txt");
		FileInputStream in2=new FileInputStream("D:\\a2.txt");
		FileInputStream in3=new FileInputStream("D:\\a3.txt");
		
		//创建Vector集合对象
		Vector<FileInputStream> v=new Vector<>();
		//把输入流对象添加到集合中
		v.add(in1);
		v.add(in2);
		v.add(in3);
		
		//获取到Enumeration---把集合中的所有输入流对象存放到e对象中
		Enumeration<FileInputStream> e=v.elements();
		
		//创建合并流对象---把含有输入流对象的e放到合并流对象中
		SequenceInputStream sis=new SequenceInputStream(e);
		
		//文件字节输出流
		FileOutputStream os=new FileOutputStream("D:\\a2.txt");
		//通过合并流对象进行统一读取数据---合并
		byte[] bs=new byte[1024*1024*10];
		int len=-1;
		while((len=sis.read(bs))!=-1){
			//写出合并之后的数据
			os.write(bs, 0, len);
		}
		//关流
		sis.close();
		os.close();	
	}
}

序列化

public class ObjectOutputStreamDemo {
	public static void main(String[] args) throws IOException {
		//创建对象
		Person p=new Person();
		//给对象属性赋值
		p.setName("lili");
		p.setAge(10);
		//开始进行序列化---创建序列化类的对象
		ObjectOutputStream oos=new ObjectOutputStream
				(new FileOutputStream("p.data"));
		//写出对象
		oos.writeObject(p);//把对象进行序列化
		//关流
		oos.close();
	}
}

反序列化

public class ObjectInputStreamDemo {
	public static void main(String[] args) throws IOException, ClassNotFoundException {
		//创建反序列化对象
		ObjectInputStream ois=new ObjectInputStream
				(new FileInputStream("p.data"));
		//读取对象---保证获取的是传入的对象
		Person p=(Person)ois.readObject();
		//关流
		ois.close();
		//获取对象属性
		System.out.println(p.getName()+","+p.getAge());
	}
}

-可变参数

可变参数—表示可以接收多个这样类型的参数
可变参数底层就是一个数组，参数的值依次存放到数组元素中
可变参数一定在最右边而且只有一个

	public static int m(int m,int... n){//n[]

-创建配置文件

public class PropertiesDemo1 {
	
	public static void main(String[] args) throws IOException {
		//创建对象
		Properties p=new Properties();
		//添加元素---键和值---字符串
		p.setProperty("name", "lili");
		p.setProperty("gender", "女");
		p.setProperty("age", "10");
		//把要存储的内容传输到配置文件中---配置文件后缀必须是.properties
		//第二个参数---文件的内容解释
	p.store(newFileOutputStream("p.properties"),"");		
	}
}




public class PropertiesDemo2 {
	
	public static void main(String[] args) throws IOException, IOException {
		//创建对象
		Properties p=new Properties();
		//加载指定配置文件
		p.load(new FileInputStream("p.properties"));
		
		//获取配置文件的内容
		//根据键获取值
		System.out.println(p.getProperty("name"));
		//根据键获取值
		System.out.println(p.getProperty("name", "tom"));
		
		//列出配置文件信息
		p.list(System.out);
	}

}

枚举
enum代表一个枚举类
枚举类所有的枚举常量必须放到首行，默认被public final static 修饰
枚举类里可以定义属性和方法
构造方法一定要私有化
可以定义抽象方法
switch-case表达式支持枚举类型
定义：

enum Season{
	spring,summer,autumn,winter;//	public final static Season spring=new Season();
	int i=0;	
}

线程

计算机在执行过程中，在同一时间只能让cpu的核执行一个进程，进程
有多个线程来执行，在同一时刻cpu只能处理一个线程
创建多线程的方式（三种）
1、继承Thread类，重写run方法（线程代码逻辑），调用start方法
用于开启线程

public class ThreadDemo1 {
	
	public static void main(String[] args) {
		//让线程执行---执行线程代码逻辑所在的类
		Demo d=new Demo();
		//开始线程---Thread类里的方法
		d.start();
		//主逻辑代码
		for (int i = 10; i >0; i--) {
			System.out.println("main:"+i);
		}
	}
}
//线程任务执行的代码逻辑
class Demo extends Thread{
	//重写方法---线程的代码逻辑
	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int i=0;i<=10;i++){
			System.out.println("i:"+i);
		}
	}
}

2、实现Runnable接口，重写run方法（线程代码逻辑），通过Runnable接口的实现类对象构建Thread类对象，调用start方法开启线程

public class ThreadDemo2 {
	
	public static void main(String[] args) {
		//通过Runnable实现类对象构建Thread类对象
		Thread t=new Thread(new TDemo());
		//开启线程
		t.start();
		for(int i=10;i>=0;i--){
			System.out.println("main:"+i);
		}
	}
}
//线程代码逻辑所在类--实现Runnable接口
class TDemo implements Runnable{
	//重写run方法---线程代码逻辑
	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int i=0;i<10;i++){
			System.out.println(i);
		}
	}
}

3、实现Callable接口，重写call方法（现阶段了解即可）

public class ThreadDemo3 {
	
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		//创建线程类对象
		DTDemo1 dt=new DTDemo1();
		//获取执行服务器
		ExecutorService e=Executors.newCachedThreadPool();
		Future<Integer> f=e.submit(dt);
		System.out.println(f.get());
	}
}
//Integer---返回值类型
class DTDemo1 implements Callable<Integer>{
	//重写方法---线程代码逻辑
	@Override
	public Integer call() throws Exception {
		// TODO Auto-generated method stub
		return 20;
	}
}

消费生产模型

//生产消费模型
public class WaitNotifyText {
	public static void main(String[] args) {
		//商品对象
		Product p=new Product();
		//开启线程
		new Thread(new Productor(p)).start();
		new Thread(new Productor(p)).start();
		new Thread(new Consumer(p)).start();
		new Thread(new Consumer(p)).start();	
	}
}
//模拟生产过程---线程逻辑代码
class Productor implements Runnable{
	//引入商品类
	Product p;
	public Productor(Product p){
		this.p=p;
	}
	//重写
	@Override
	public void run() {
		while (true) {
			synchronized (p) {
				while(p.flag==true)//加上while保证线程一定会进行判断
					try {
						p.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				// TODO Auto-generated method stub
				// 此时生产的最大值
				int max = 1000 - p.getNum();// 减去上次剩余
				// 随机生产的商品数量
				int count = (int) (Math.random() * (max + 1));
				// 设置新的商品数量
				p.setNum(p.getNum() + count);
				// 输出
				System.out.println("此次生产了" + count + "个商品,还剩余" + p.getNum() + "个商品...");
				//唤醒
				//p.notify();//随机唤醒一个
				p.notifyAll();
				p.flag=true;
			}
		}
	}
}
//模拟消费过程
class Consumer implements Runnable{
	// 引入商品类
	Product p;
	public Consumer(Product p){
			this.p=p;
		}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		while (true) {
			synchronized (p) {
				while(p.flag==false)
					try {
						p.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				// 此次消费最大值
				int max = p.getNum();
				// 此次消费的随机商品数量
				int count = (int) (Math.random() * (max + 1));
				// 设置新的商品数量
				p.setNum(p.getNum() - count);
				// 输出
				System.out.println("此次消费了" + count + "个商品,还剩余" + p.getNum() + "个商品...");
				//唤醒
				//p.notify();
				p.notifyAll();
				p.flag=false;
			}
		}
	}
}
//商品类
class Product{
	//商品数量
	private int num;
	boolean flag=true;
	public int getNum() {
		return num;
	}
	public void setNum(int num) {
		this.num = num;
	}	
}

网络编程

发送端
1.创建套接字对象
2.创建数据包，指定数据发送的IP地址、长度、以及端口号
3.发送数据包
4.关流
-接收端
1.创建套接字对象，绑定具体的端口号
2.创建数据包，指定真实接收数据的长度
3.接收数据包
4.关流
5.解析数据包
UDP发送端

public class UDPSenderDemo {
       
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		DatagramSocket ds=new DatagramSocket();
		//创建待传输数据包
		//第一个参数要传输的数据的字节数组
		//第二个参数真正要发送数据的长度(最大和数组长度一致)
		//第三个参数指明要传输的IP地址和端口号
		DatagramPacket dp=new DatagramPacket
				("好久不见！！！".getBytes(),"好久不见！！！".getBytes().length, 
						new InetSocketAddress("127.0.0.1",8099));
		ds.send(dp);
		ds.close();
	}
}

UDP接收端

public class UDPReceiverDemo {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		while (true) {
			DatagramSocket ds = new DatagramSocket(8099);
			//创建数据包用于接收数据---第二个参数代表实际接收数据的长度
			DatagramPacket dp = new DatagramPacket(new byte[1024], 1024);
			ds.receive(dp);//接收数据包
			ds.close();
			//解析数据包
		    //dp.getData()---获取数据--字节数组
			System.out.println(new String(dp.getData(), 0, dp.getLength()));
			System.out.println(dp.getAddress());
			System.out.println(dp.getSocketAddress());
		}
	}
}

UDP聊天室

public class UDPChatDemo {
	public static void main(String[] args) {
		//开启线程
		new Thread(new Sender()).start();
		new Thread(new Receiver()).start();
	}
}
//发送端---线程
class Sender implements Runnable{
	//声明对象
	DatagramSocket ds;
	DatagramPacket dp;
	Scanner sc;
	@Override
	public void run() {
		// TODO Auto-generated method stub
		//对象初始化
		try {
			ds=new DatagramSocket();
			sc=new Scanner(System.in);
			while(true){//保证一致写数据---发送数据
				//录入数据
				byte[] bs=sc.nextLine().getBytes();
				//创建发送的数据包
				 dp=new DatagramPacket(bs, bs.length,
								new InetSocketAddress("127.0.0.1",8090));
			     //发送数据包
				ds.send(dp);
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}		
	}
}
//接收端
class Receiver implements Runnable{
	//声明对象
	DatagramSocket ds;
	DatagramPacket dp;
	@Override
	public void run() {
		// TODO Auto-generated method stub
		//对象初始化
		try {
			ds=new DatagramSocket(8090);
			dp=new DatagramPacket(new byte[1024],1024);
		} catch (SocketException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		while(true){
			//接收数据包
			try {
				ds.receive(dp);
				//解析数据包
				System.out.println(new String(dp.getData(),0,dp.getLength()));
				System.out.println(dp.getAddress());
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}	
}

TCP

客户端
1、创建TCP客户端对象
2、发起链接（指明要发送的IP和端口）
3、获取自带的字节输出流
4、根据自带的字节流往服务器端写出数据
5、通知服务器已经写完、关流
服务器端
1、创建TCP服务器端对象，绑定端口
2、接收链接
3、获取自带字节流
4、通过自带的字节流进行数据读取
5、通知客户端已经读取完成、关流
TCP客户端

public class TCPClientDemo {
	
	public static void main(String[] args) throws IOException {
		//创建TCP的套接字对象
		Socket s=new Socket();
		//发起链接---指定链接的IP和端口
		s.connect(new InetSocketAddress("127.0.0.1", 8010));
		//获取自带的字节输出流
		OutputStream os=s.getOutputStream();
		//写出的数据默认往服务器端写
		//通过自带的字节输出流写数据
		os.write("服务器你好...".getBytes());
		//通知服务端数据已写完
		s.shutdownOutput();


		//获取自带字节输入流，默认接收从服务器端发送过来的数据
		InputStream in=s.getInputStream();
		//读取数据
		byte[] bs=new byte[1024];
		int len=-1;
		while((len=in.read(bs))!=-1){
			System.out.println(new String(bs,0,len));
		}
		//通知服务器端已读取完成
		s.shutdownInput();
		//关流
		os.close();
		in.close();
	}
}

TCP服务器端

public class TCPServerDemo {
	public static void main(String[] args) throws IOException {
		//创建TCP服务器端对象---绑定端口
		ServerSocket ss=new ServerSocket(8010);
		//接收链接
		Socket s=ss.accept();
		//获取自带的输入流
		InputStream in=s.getInputStream();
		//自建缓冲区
		byte[] bs=new byte[1024];
		int len=-1;
		//读取传过来的数据
		while((len=in.read(bs))!=-1){//读取有阻塞
			System.out.println(new String(bs,0,len));
		}
		//通知客户端数据已读完
		s.shutdownInput();
		
		
		//获取自带的字节输出流
		OutputStream os=s.getOutputStream();
		//往客户端写出数据
		os.write("你也好...".getBytes());
		//通知客户端数据已写完
		s.shutdownOutput();
		//关流
		in.close();
		os.close();
	}
}

反射

获取字节码对象
获取构造方法
传参——构建实例对象
…

Class—代表类的类—代表.class的类
Field—代表属性的类
Method–代表方法的类
Construct—代表构造方法的类
Annotation—代表注解的类
Package—代表包的类

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class ClassDemo2 {
	public static void main(String[] args) throws InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException, ClassNotFoundException {
		//先获取String的字节码对象
		Class<String> clz=String.class;
		//获取实例对象
		//newInstance()---默认在调用类的无参构造
		//String str=clz.newInstance();
		
		//通过字节码对象调用到String类的有参构造
		Constructor c=clz.getConstructor(char[].class);//传入构造方法参数类型的字节码对象
		//获取到的有参构造调用newInstance()传入实际参数构造实例对象
		String str=(String) c.newInstance
				(new char[]{'1','4','a'});
		
		//获取构造方法 
		Constructor c1=clz.getConstructor(String.class);
		//暴力破解---可以操作特殊的构造方法(若私有化)
		//c1.setAccessible(true);
		//传参--构建实例对象
		String str1=(String) c1.newInstance("abc");
		//获取指定的方法
		Method m=clz.getDeclaredMethod
				("charAt", int.class);
		//调用方法
		char c=(char) m.invoke(str, 3);
		//获取指定的属性---hash
		Field f=clz.getDeclaredField("hash");
		//暴力破解
		f.setAccessible(true);
		//通过Integer的全路径名获取Integer的实例对象并赋值
		//通过Class.forName()获取字节码对象
		Class<Integer> clz1=(Class<Integer>) 
				Class.forName("java.lang.Integer");
		//获取有参构造方法 new Integer(int )
		Constructor c2=clz1.getConstructor(int.class);
		//传参--构建实例对象
		Integer in=(Integer) c2.newInstance(123);
		System.out.println(in);
	}
}

注解

给计算机看的注释
注解属性默认被public static final共同修饰
支持的属性类型—基本数据类型、String、Class、Annotation、枚举以及对应形式的一维数组表现形式

元注解
用于控制、限制注解的使用情况（给注解的注解）
@Target—控制注解可以在什么位置使用
@Retention—控制注解的级别
@Documented—可以让注解随着类一起文档化出去
@Inherited—可以让子类依然具有注解

@First()
	public class AnnoDemo1 {
		@First()
		int i=1;
		@First()
		public static void main(@First() String[] args) {
			@First()
			int j=10;
		}
	}
	//自定义注解
	//@Target({ElementType.TYPE,ElementType.METHOD})
	//@Retention(RetentionPolicy.SOURCE)
	@Inherited
	@interface First{
		/*//默认被public static final共同修饰
		public static final int i=10;
		double d();//声明属性没有赋值
		//Object类型不在支持范围之内
		//Object od();
		int[] arr();//一维数组
	*/}