总结
第一天
单列模式:
? 始终在内存中创建一个实例
分为两种:
? 饿汉式:永远不会出现问题的单列模式(最简单的一种模式)
? 懒汉式:可能会出现问题的一种单列模式
饿汉式
? 1构造方法私有:保证外界不能直接创建当前类对象
? 2在当前类的成员位置:创建当前类实例
? 3提供一个静态的功能,返回值就是当前类本事(需要当前类的实例)
代码实现:
public class Student{
private static Student s = new Student();
private static Student s = new Student();
private Studen(){}
public static Student getStudentInstance(){
return s;
}
}
public class Single_Pattern_01{
public static void main(String[] args){
Student s1 =Student.getStudentInstance();
Student s2 =Student.getStudentInstance();
Student s3 =Student.getStudentInstance();
Student s4 =Student.getStudentInstance();
System.out.println(s1==s2);
System.out.println(s1==s3);
System.out.println(s1==s4);
}
}
懒汉式:可能出现问题的一种单列模式
? 1构造方法私有化
? 2在当前成员变量的位置声明变量:数据类型就是当前类(私有的,静态的)
? 3提供静态功能,返回值还是当前类本身,判断如果当前没有给当前类型变量为null,直接new 当期类的实例如果不为null,就返回当前类的变量!
代码实现:
public class Woker{
privae static Woker w;
private WWoker(){}
publicsynchronized static Woker getWokerInstance(){
if(w==null){
w= new Woker();
return w;
}
return w ;
}
}
public class Single_pattern_02 {
public static void main(String[] args) {
Worker w1 = Worker.getWorkerIntance();
Worker w2 = Worker.getWorkerIntance();
System.out.println(w1==w2);
Worker w3 = Worker.getWorkerIntance();
System.out.println(w1==w3);
}
}
IO流
File文件和目录(文件夹)路径名饿的抽象表示.
构造方法
File(String pathname):参数就是指定的路径/如果没有指定路劲(默认在当前项目下)通过将给定的路径名字符串转换为抽象路径名来创建新的的File实例
File(File parent, Srting child):参数1:父目录地址 参数2:具体的子文件地址
成员方法:
? 创建/删除/重名
public boolean createNewFile() throws IOException:表示创建文件夹,如果不存在,则创建;
public boolean mkdir():创建文件夹,如果不存在,则创建;否则就返回false;
public boolean mkdirs():创建多个文件,如果父目录不存在,则创建
public boolean delete():删除文件或者文件夹(如果删除文件夹,文件夹必须为空目录)
public boolean renameTo(File dest):重命名
判断功能
public boolean canRead()是否可读
public boolean canWrite()是否可写
public boolean exists():是否存在
public boolean isFile():是否是文件
public boolean isDirectory():是否是文件夹
public boolean isHidden():是否隐藏
高级获取功能:
public long length()
public String getName():获取抽象路径 名所表示的文件或者目录的名称
public File[] listFiles():获取某个目录下的所有的文件以及文件夹的File数组
public String[] list():获取某个抽象路径名所表示的文件以及目录的字符串数组
代码实现:获取D盘下的所有的文件夹以及文件的名称…
public class FileDemo2{
public static void main(String[] args){
File f1 = new File( "d://");
File[] fileArray = f1.listFiles();
if(fileArray!==null){
for(File f:fileArray){
System.out.println(f.getname());
}
}
}
}
需求2:
-
获取D盘下所有的以.jpg结尾的文件 -
分析: -
1)描述下D盘 -
- public File[] listFiles():获取D盘下的所有的文件以及文件夹的File数组
-
2.1)对获取到的数组进行非判断 -
如果不为null,再去判断 -
2.2)判断File是一个文件 -
2.3)判断:文件必须以.jpg结尾 -
String类 endsWith(".jpg") public class FileTest{
public static void main(String[] args){
File file = new File("d://");
File[] fileArray =file.listFiles(new FilenameFilter(){
}@Override
public boolean accept(File dir, String name) {
File file = new File(dir, name);
return file.isFile() && file.getName().endsWith(".jpg");
}
});
if(files!=null){
for(File f :files){
System.out.println(f.getName());
}
}
}
}
IO流的分类: * 流的方向划分:
输入流: 读数据
输出流: 写数据
流的类型划分:
字节流:
字节输入流
InputStream
FileInputStream
高效的字节输入流(字节缓冲输入流)
BufferedInputStream
合并输入流:SequenceInputStream :只能操作源文件
可以将多个文件复制到一个文件中...
字节输出流
OutputStream
FileOutputStream
BufferedOutputStream:高效字节输出流 (字节缓冲输出流)
字符流:
针对中文字符进行读取:保证编码和解码的格式统一
编码:Writer
OutputStreamWriter(OutputStream out):平台默认编码集
OutputStreamWriter(OutputStream out,String charset):指定平台字符集进行编码
字符缓冲输出流:
BufferedWriter
newLine()
解码:Reader
InputStreamReader(InputStream in):平台默认的解码集
InputStreamReader(InputStream in,String charset)指定平台字符集进行解码
字符缓冲输入流:BufferedReder
readLine():第一行内
文本文件:----->使用字符流
图片文件,视频文件,音频文件---->都可以字节流
字节输入流:InputStream 子类:FileInputStream 需求:需要读取当前项目下的s.txt文件 (1)创建文件字节流对象,指向s.txt文件 (2)读内容 read(byte[] bytes):一次读取一个字节数组 read():一次读取一个字节 (3)释放资源 针对中文字符: 现在idea环境: 编码格式:utf-8格式: 一个中文对应三个字节 ,和前面的英文拼接出现问题,只要中文都会乱码,才出现了字符流(加入编码和解码的格式) package lx;
import java.io.FileInputStream;
import java.io.IOException;
public class Text {
public static void main(String[] args) {
FileInputStream fileInputStream =null;
try {
fileInputStream = new FileInputStream("s.txt");
int by =0;
while((by=fileInputStream.read())!=-1){
System.out.print((char)by);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fileInputStream!=null){
try {
fileInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
读取一个字节数组:一次读取一个字节数组,返回值是每次读取的实际字节数 需求:将s.txt读取出来,并展示在控制台上 package lx;
import java.io.FileInputStream;
import java.io.IOException;
public class Test1 {
public static void main(String[] args) {
FileInputStream fileInputStream = null;
try {
fileInputStream = new FileInputStream("s.txt" );
byte[] bytes =new byte[1024];
int len = 0;
while((len=fileInputStream.read(bytes))!=-1){
System.out.println(new String(bytes,0,len));
}
} catch (IOException e) {
e.printStackTrace();
} finally {
}
try {
fileInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
读写复制操作:一次读取一个字节的方式,一次读取一个字节数组 将当前项目下的s.txt的内容 复制到D盘下的s.txt文件中 package lx;
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class Text2 {
public static void main(String[] args) throws Exception {
FileInputStream fileInputStream = new FileInputStream("s.txt");
FileOutputStream fileOutputStream = new FileOutputStream("ss.txt");
byte[] bytes =new byte[1024];
int len = 0;
while((len=fileInputStream.read(bytes))!=-1){
fileOutputStream.write(bytes,0,len);
fileOutputStream.close();
fileOutputStream.close();
}
}
}
字节缓冲输出流 BufferedOutputStream(OutputStream out) 推荐使用这个:默认缓冲区大小 足够大了 8kb 创建一个新的缓冲输出流，以将数据写入指定的底层输出流。BufferedOutputStream(OutputStream out, int size) package lx; import java.io.BufferedOutputStream; import java.io.FileOutputStream;public class Test { public static void main(String[] args) throws Exception { BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("s.txt")); bufferedOutputStream.write("hello,yanshan".getBytes()); bufferedOutputStream.flush(); bufferedOutputStream.close(); }}
字节缓冲输入流 BufferedInputStream(InputStream in) :默认缓冲区大写 (足够大了) 提供一个指定的缓冲区大小BufferedInputStream(InputStream in, int size) package lx; import java.io.BufferedOutputStream; import java.io.FileOutputStream; public class Test { public static void main(String[] args) throws Exception { BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("s.txt")); bufferedOutputStream.write("hello,yanshan".getBytes()); bufferedOutputStream.flush(); bufferedOutputStream.close(); } }
利用字节缓冲输入流,输出流将"s.txt"写入到"ss.txt"中 package lx;import java.io.BufferedInputStream;import java.io.BufferedOutputStream;import java.io.FileInputStream;import java.io.FileOutputStream;public class Test2 { public static void main(String[] args) throws Exception { BufferedInputStream bis =new BufferedInputStream(new FileInputStream("s.txt")); BufferedOutputStream bos =new BufferedOutputStream(new FileOutputStream("ss.txt")); byte[] bytes = new byte[1024]; int len =0; while ((len=bis.read(bytes))!=-1){ bos.write(bytes,0,len); } bos.close(); bis.close(); }}
字符流 OutputStreamWriter: 字符流的出现是在字节流的后面,可以解决中文乱码问题
package lx;import java.io.FileInputStream;import java.io.InputStreamReader;public class Test4 { public static void main(String[] args) throws Exception { InputStreamReader is = new InputStreamReader(new FileInputStream("s.txt")); char[] chars = new char[1024]; int len = 0; while ((len=is.read(chars))!=-1){ System.out.println(new String(chars,0,len)); } is.close(); }}
用字符输出,输入流将"s.txt"写入到"ss.txt"中
package lx;import java.io.*;public class Test6 { public static void main(String[] args) throws Exception { InputStreamReader is =new InputStreamReader(new FileInputStream("s.txt")); OutputStreamWriter os = new OutputStreamWriter(new FileOutputStream("ss.txt")); char[] chars = new char[1024]; int len =0; while ((len=is.read(chars))!=-1) { os.write(chars); os.flush(); } os.close(); is.close(); }}
BufferedWriter:
字符缓冲输出流
BufferedWriter(Writer out) :创建默认的缓冲区大小: 默认大小:defaultcharbuffersize:8192(默认值足够大)
BufferedWriter(Writer out, int sz) :指定的大小
public void newLine() throws IOException:写入行的分隔符号
package lx;import java.io.BufferedWriter;import java.io.FileWriter;import java.io.IOException;public class Test7 { public static void main(String[] args) throws Exception { BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("s.txt")); bufferedWriter.write("gdbdh"); bufferedWriter.newLine(); bufferedWriter.write("我爱严珊"); bufferedWriter.newLine(); bufferedWriter.flush(); bufferedWriter.close(); }}
字符缓冲输入流:
BufferedReader ---- 键盘录入数据 Scanner(InputSteram in) String nextLine()
BufferedReader(Reader in)
Reader
InputStreamReader(InputStream in):转换流
如果直接进行读的操作(直接操作文件)FileReader(String pathName)
创建使用默认大小的输入缓冲区的缓冲字符输入流。
BufferedReader(Reader in, int size) :指定缓冲区大小
特有功能:public String readLine() :一次读取一行内容
package lx;import java.io.BufferedReader;import java.io.FileReader;public class Test8 { public static void main(String[] args) throws Exception { BufferedReader br = new BufferedReader(new FileReader("s.txt"));
用字符缓冲输入流,输出流将"s.txt"写入到"ss.txt"中
package lx;import java.io.*;public class Test9 { public static void main(String[] args) throws Exception { BufferedReader bufferedReader =new BufferedReader(new FileReader("s.txt")); BufferedWriter bufferedWriter =new BufferedWriter(new FileWriter("ss.txt")); String line = null; while ((line=bufferedReader.readLine())!=null){ bufferedWriter.write(line); bufferedWriter.newLine(); bufferedWriter.flush(); } bufferedWriter.close(); bufferedReader.close(); }}
SequenceInputStream:
字节流的逻辑串联!
可以将两个或者是两个以上的文件进行读的操作 ,只能操作源文件
构造方法
public SequenceInputStream(InputStream s1,InputStream s2)
参数1和参数2:分别要读取的字节输入流对象
package lx;import java.io.*;public class Test10 { public static void main(String[] args) throws Exception { FileInputStream f1 = new FileInputStream("s.txt"); FileInputStream f2 = new FileInputStream("ss.txt"); SequenceInputStream si =new SequenceInputStream(f1,f2); BufferedOutputStream bufferedOutputStream =new BufferedOutputStream(new FileOutputStream("c.txt")); byte[] bytes =new byte[1024]; int len =0; while ((len=si.read(bytes))!=-1){ bufferedOutputStream.write(bytes); } bufferedOutputStream.flush(); bufferedOutputStream.close(); }}
public SequenceInputStream(Enumeration<? extends InputStream> e) :将两个以上的文件进行读取
Vector
add(添加多个字节输入流对象)
package lx;import java.io.BufferedOutputStream;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.SequenceInputStream;import java.util.Enumeration;import java.util.Vector;public class Test11 { public static void main(String[] args) throws Exception { FileInputStream f1 =new FileInputStream("s.txt"); FileInputStream f2 = new FileInputStream("ss.txt"); FileInputStream f3 = new FileInputStream("c.txt"); Vector<FileInputStream>vector = new Vector<>(); vector.add(f1); vector.add(f2); vector.add(f3); Enumeration<FileInputStream> elements = vector.elements(); SequenceInputStream sis =new SequenceInputStream(elements); BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("cc.txt")); int len = 0; while ((len=sis.read())!=-1){ bos.write(len); } bos.flush(); bos.close(); }}
序列化 ,反序列化
列化:ObjectOutputStream
将某个实体对象写入到流对象中---->将一个对象变成 流数据
构造方法
protected ObjectOutputStream()
protected ObjectOutputStream(OutputStream out) :将某个对象通过底层的基本字节输出进行写的动作
public final void writeObject(Object obj)
throws IOException
需求:将Person p = new Person(“严珊”,28) ;---->变成流对象 进行传输
反序列化:ObjectInputStream
将流数据----还原成 “对象”
构造方法
public ObjectInputStream(InputStream in)
public final Object readObject()
throws IOException, ClassNotFoundException
package lx;import java.io.*;class Person implements Serializable { String name; private transient int age;
Properties extends Hashtable<K,V> ,它没有泛型,Key和Value都是String
表示一组持久的属性。 Properties可以保存到流中或从流中加载。
属性列表中的每个键及其对应的值都是一个字符串。
1)可以使用Map的功能
put(K ,V)
遍历:
keySet()通用
2)有自己特有功能添加元素和遍历
public Object setProperty(String key,String value):给属性列表中添加属性描述(key和value)
public Set stringPropertyNames():获取属性列表中的所有的键
public String getProperty(String key):在属性列表中通过键获取值
package lx;import java.io.*;class Person implements Serializable { String name; private transient int age;
有一个文本文件s.txt，如果里面键是lisi，
然后将他的年龄改为28，然后重新写入到s.txt文件中
yanshan=30
penggang=22
package lx;import java.io.*;import java.util.Properties;import java.util.Set;public class Test13 { public static void main(String[] args) throws IOException { Properties properties = new Properties(); FileReader fileReader = new FileReader("s.txt"); properties.load(fileReader); Set<String> strings = properties.stringPropertyNames(); for (String key: strings){ if ("yanshan".equals(key)){ properties.setProperty(key,"28"); } } FileWriter fileWriter = new FileWriter("s.txt"); properties.store(fileWriter,"s'namelist"); }}
网络编程—>socket编程
网络编程三要素
ip
port
规定一种协议
udp协议:1不需要建立通道2.属于一种不可靠的连接3.发送文件大小限制的4.执行效率高(不同步的)
tcp/ip协议:1.建立连接通道2.属于安全连接(可靠连接)3.发送文件(使用基本字节流),相对udp协议 来说没有限制
4执行效率低()同步的
udp编程的发送端
Udp编程的发送端：
1）创建Socket对象
2)发送内容 :内容数据一种数据报文(报包)DatagramPacket
3)释放资源
package lx;import java.io.IOException;import java.net.*;public class Test14 { public static void main(String[] args) throws IOException { DatagramSocket ds = new DatagramSocket(); byte[] bytes = "严珊,hello".getBytes(); int length = bytes.length; InetAddress byName = InetAddress.getByName("192.168.1.9"); int port =23232; DatagramPacket dp = new DatagramPacket( bytes ,length,byName,port); ds.send(dp); ds.close(); }}
Udp接收端
1)创建Socket对象
2)创建一个接收容器:数据报包:DatagramPacket
3)接收
4)解析容器的的实际数据大小
5)展示发送端发送的数据
package lx;import java.io.IOException;import java.net.DatagramPacket;import java.net.DatagramSocket;public class Test15 { public static void main(String[] args) throws IOException {
TCP特点:需要建立连接通道(就是以一种字节流的方式写入,读取)
什么时候建立连接(服务器端如果监听到端口,客户端就立即和服务器端建立连接!)
TCP客户端写数据
1)创建TCP客户端的Socket对象
2)写数据
3)释放资源
package lx;import java.io.IOException;import java.io.OutputStream;import java.net.Socket;public class Test16 { public static void main(String[] args) throws Exception { Socket s = new Socket("192.168.1.9",34343); OutputStream outputStream = s.getOutputStream(); outputStream.write("hello,严珊".getBytes()); s.close(); }}
TCP服务器端的实现步骤:
1)创建服务器端的Socket对象
public ServerSocket(int port)throws IOException
2)监听客户端连接
public Socket accept()throws IOException 返回值就是当前监听到的客户端的Socket对象
3)获取通道内的输入流
public InputStream getInputStream() throws IOException
4)读取数据:一次读取一个字节数组
5)展示数据 而且获取ip地址
package lx;import java.io.IOException;import java.io.InputStream;import java.net.ServerSocket;import java.net.Socket;public class Test17 { public static void main(String[] args) throws IOException { ServerSocket serverSocket = new ServerSocket(8888); System.out.println("该服务器正在连接"); Socket s = serverSocket.accept(); InputStream inputStream = s.getInputStream(); byte[] bytes = new byte[1024]; int read = inputStream.read(bytes); String s1 = new String(bytes, 0, read); String hostAddress = s.getInetAddress().getHostAddress(); System.out.println(hostAddress+s1); }}
tcp端:
1)TCP客户端不断键盘录入数据,服务器端不断接收数据,然后展示数据
2)TCP客户端文本文件(XXX.java文件)----->服务器端将文件进行读写复制,输出到当前项目的Copy.java文件中
BuferedReader
3)TCP客户端文本文件(XXX.jpg文件)----->服务器端将文件进行读写复制,输出到当前项目的Copy.jpg文件中
BufferedInputStream
package lx;import java.io.*;import java.net.Socket;public class Test18 { public static void main(String[] args) { Socket s= null; try { s = new Socket("10.12.156.107",10010); BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); String line = null; while ((line=br.readLine())!=null){ if ("over".equals(line)){ break; } } BufferedWriter bw= new BufferedWriter(new OutputStreamWriter(s.getOutputStream())); bw.write(line); bw.newLine(); bw.flush(); } catch (IOException e) { e.printStackTrace(); } finally { if (s!=null){ try { s.close(); } catch (IOException e) { e.printStackTrace(); } } } }}
tcp端的服务端:
package lx;import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;import java.net.ServerSocket;import java.net.Socket;public class Test19 { public static void main(String[] args) { try { ServerSocket ss = new ServerSocket(10010); while (true) { System.out.println("服务器正在连接"); Socket socket = ss.accept(); BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream())); String line = null; while ((line=br.readLine())!=null) { System.out.println(line); } } } catch (IOException e) { e.printStackTrace(); } finally { } }}
客户端的一个文本文件,服务器端进行复制到指定的某个文件中 ,复制完毕了,服务器端需要给客户端反馈!(反馈的消息,客户端能不能获取到)
package lx;import java.io.*;import java.net.Socket;public class Test20 { public static void main(String[] args) throws IOException { Socket s = new Socket("10.12.156.107",10086); BufferedReader br = new BufferedReader(new FileReader("s.txt")); BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream())); String line = null; while ((line=br.readLine())!=null){ bw.write(line); bw.newLine(); bw.flush(); }s.shutdownOutput(); InputStream inputStream = s.getInputStream(); byte[] bytes = new byte[1024]; int read = inputStream.read(bytes); String s1 = new String(bytes, 0, read); br.close(); s.close(); }}
服务器端
package lx;import java.io.*;import java.net.Socket;public class Test20 { public static void main(String[] args) throws IOException { Socket s = new Socket("10.12.156.107",10086); BufferedReader br = new BufferedReader(new FileReader("s.txt")); BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream())); String line = null; while ((line=br.readLine())!=null){ bw.write(line); bw.newLine(); bw.flush(); }s.shutdownOutput(); InputStream inputStream = s.getInputStream(); byte[] bytes = new byte[1024]; int read = inputStream.read(bytes); String s1 = new String(bytes, 0, read); br.close(); s.close(); }}
反射
什么是反射?
能够获取当前某个类的字节码文件对象Class,那么就可以获取当前类的构造器并且创建当前类实例,
还可以获取当前类的成员变量并去赋值,或者获取当前类的成员方法并去调用!
如何获取一个类的字节码文件对象?
Object类的getClass()获取 获取当前某个类的实例(正在运行的类)
任意Java类型的class属性
Class类的静态功能
public static Class<?> forName(String className)
通过反射获取字节码,再进行对成员变量赋值
package lx;public class Person1 { private String name; public int age; String addres; public Person1() { } public Person1(String name, int age, String addres) { this.name = name; this.age = age; this.addres = addres; } public void show(){ System.out.println("show person"); } private String funcation(String str){ return str; } void method(String message , int num){ System.out.println(message+num); } public int methhod1(){ return 100; } @Override public String toString() { return "Person1{" + "name='" + name + '\'' + ", age=" + age + ", addres='" + addres + '\'' + '}'; }}package lx;import java.lang.reflect.Constructor;import java.lang.reflect.InvocationTargetException;public class Test22 { public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException { Class aClass = Class.forName("lx.Person1"); Constructor c = aClass.getDeclaredConstructor(String.class, int.class, String.class); c.setAccessible(true); Object obj = c.newInstance("严珊", 28, "西安市"); System.out.println(obj); }}
对成员方法进行调用和赋值
package lx;import java.lang.reflect.Constructor;import java.lang.reflect.InvocationTargetException;import java.lang.reflect.Method;public class Test23 { public static void main(String[] args) throws Exception { Class aClass = Class.forName("lx.Person1"); Object obj = aClass.newInstance(); Method show = aClass.getMethod("show"); show.invoke(obj); Method funcation = aClass.getDeclaredMethod("funcation", String.class); funcation.setAccessible(true); Object dd = funcation.invoke(obj, "我爱严珊"); System.out.println(dd); }}
数据库
1.表的增删查改
create table 表明( 列名1 字段类型1, 列名2 字段类型2, ... 列名n 字段类型n) ; 数据库常用的字段类型int------>默认int(11) 取的是当前实际长度 (推荐) id int,---编号 1 int(长度):指定长度 id int(3) 1---->001 varchar(字符长度):字符串类型数据 '' "" 不写 引号 ,习惯去使用''或者双引号double(值1,值2):小数类型 举例 double(3,2) ----小数类型,3位数,小数点后保留2位 123.56日期类型 date 仅仅表示日期,不表示时分秒 "2021-8-12" datatime 不仅表示日期具体的时间 "2021-8-12 17:31:00" timestap:时间戳 给表中插入数据, 显示当前插入/修改/删除/查询数据那一刻时间 (具体到秒"2021-8-12 18:00:01") 注意事项:就是给那一个库中创建表 使用哪个库(选择数据库名) use 库名;mysql> use mydb_01;Database changedmysql>mysql> create table student( -> id int, -> name varchar(20), -> gender varchar(10), -> address varchar(50), -> age int -> ) -> ;Query OK, 0 rows affected (0.05 sec)
|