ToB企服应用市场:ToB评测及商务社交产业平台

标题: 软件计划之Java入门视频(20) [打印本页]
作者: 灌篮少年    时间: 2024-8-29 21:22
标题: 软件计划之Java入门视频(20)
软件计划之Java入门视频(20)

视频教程来自B站尚硅谷：
   尚硅谷Java入门视频教程，宋红康java基础视频
相干文件资料（百度网盘）
提取密码：8op3
idea 下载可以关注 软件管家 公众号
  学习内容：

该视频共分为1-717部门
本次内容涉及 600-629
在写代码时，总是必要来回切换界面来看代码要求，这里推荐Snipaste，可以把截图以窗口形式放在屏幕上
记录内容：
1、转换流

   转换流：属于字符流
1、InputStreamReader：将一个字节的输入流转换为字符的输入流
2、OutputStreamWriter：将一个字符的输出流转换为字节的输出流
作用：提供字节省与字符流之间的转换
3、解码：字节、字节数组–>字符数组、字符串
4、编码：字符数组、字符串–>字节、字节数组
  1. @Test
  2.     public void test()  {
  3.         InputStreamReader isr = null;
  4.         try {
  5.             FileInputStream fis = new FileInputStream("hello.txt");
  6.             //参数2指明了字符集，具体使用了哪个字符集，取决于文件hello.txt保存时使用的字符集
  7.             isr = new InputStreamReader(fis,"UTF-8");
  9.             char[] cbuf = new char[20];
  10.             int len;
  11.             while ((len = isr.read(cbuf)) != -1){
  12.                 String str = new String(cbuf,0,len);
  13.                 System.out.print(str);
  14.             }
  15.         } catch (IOException e) {
  16.             throw new RuntimeException(e);
  17.         } finally {
  18.             try {
  19.                 isr.close();
  20.             } catch (IOException e) {
  21.                 throw new RuntimeException(e);
  22.             }
  23.         }
  24.     }
复制代码
文件复制–转换流

  1. @Test
  2.     public void test1() throws IOException {
  3.         File file1 = new File("hello.txt");
  4.         File file2 = new File("hello_gbk.txt");
  6.         FileInputStream fis = new FileInputStream(file1);
  7.         FileOutputStream fos = new FileOutputStream(file2);
  9.         InputStreamReader isr = new InputStreamReader(fis,"UTF-8");
  10.         OutputStreamWriter osw = new OutputStreamWriter(fos,"GBK");
  11.         char[] cbuf = new char[20];
  12.         int len;
  13.         while ((len = isr.read(cbuf)) != -1){
  14.             osw.write(cbuf,0,len);
  15.         }
  16.         isr.close();
  17.         osw.close();
  18.     }
复制代码
2、其他流的利用

   1、标准的输入、输出流
2、打印流
3、数据流：用于读取或写出基本数据类型的变量或字符串
4、网络编程概述
  输入流测试

   键盘输入字符串，要求读取的整行字符串转成大写输出，然后继续进行输入操作。直至输入"e"或"exit"时，退出程序
  1.     public static void main(String[] args) {
  2.         BufferedReader br = null;
  3.         try {
  4.             InputStreamReader isr = new InputStreamReader(System.in);
  5.             br = new BufferedReader(isr);
  7.             while(true){
  8.                 System.out.println("输入：");
  9.                 String data = br.readLine();
  10.                 if ("e".equalsIgnoreCase(data) || "exit".equalsIgnoreCase(data)){
  11.                     System.out.println("程序结束");
  12.                     break;
  13.                 }
  14.                 String upperCase = data.toUpperCase();
  15.                 System.out.println(upperCase);
  16.             }
  17.         } catch (IOException e) {
  18.             throw new RuntimeException(e);
  19.         } finally {
  20.             try {
  21.                 br.close();
  22.             } catch (IOException e) {
  23.                 throw new RuntimeException(e);
  24.             }
  25.         }
  26.     }
复制代码
打印流测试

  1.     @Test
  2.     public void test1() {
  3.         PrintStream ps = null;
  4.         try {
  5.             FileOutputStream fos = new FileOutputStream(new File("D:\\IO\\text.txt"));
  6. // 创建打印输出流,设置为自动刷新模式(写入换行符或字节 '\n' 时都会刷新输出缓冲区)
  7.             ps = new PrintStream(fos, true);
  8.             if (ps != null) {// 把标准输出流(控制台输出)改成文件
  9.                 System.setOut(ps);
  10.             }
  11.             for (int i = 0; i <= 255; i++) { // 输出ASCII字符
  12.                 System.out.print((char) i);
  13.                 if (i % 50 == 0) { // 每50个数据一行
  14.                     System.out.println(); // 换行
  15.                 }
  16.             }
  17.         } catch (FileNotFoundException e) {
  18.             e.printStackTrace();
  19.         } finally {
  20.             if (ps != null) {
  21.                 ps.close();
  22.             }
  23.         }
  24.     }
复制代码
数据流测试

  1.     @Test
  2.     public void test1() throws IOException {
  3.         DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));
  5.         dos.writeUTF("AAA");
  6.         dos.flush();
  7.         dos.writeInt(123);
  8.         dos.flush();
  9.         dos.writeBoolean(true);
  10.         dos.flush();
  11.         dos.close();
  12.     }
  13.     @Test
  14.     public void test2() throws IOException {
  15.         DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
  16.         String name = dis.readUTF();
  17.         int i = dis.readInt();
  18.         boolean b = dis.readBoolean();
  19.         System.out.println("name=" + name);
  20.         System.out.println("i=" + i);
  21.         System.out.println("b=" + b);
  22.     }
复制代码
3、对象流

   用于存储和读取基本数据类型或对象的处理流，可以把Java中的对象写入到数据流中，也能把对象从数据源中还原
1、序列化：将内存中的java对象生存到磁盘中或通过网络传输出去
2、反序列化：将磁盘文件中的对象还原为内存中的一个java对象
3、可序列化类条件：
①必要实现接口Serializable
②当前类提供一个全局常量：serialVersionUID
③当前类内部所有属性也必须是可序列化的
增补：ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量
  可序列化类展示

  1. public class Person implements Serializable {
  2.     public final long serialVersionUID = 432142132L;
  3.     private String name;
  4.     private int age;
  5.     public Person(String name, int age) {
  6.         this.name = name;
  7.         this.age = age;
  8.     }
  9.     public String getName() {
  10.         return name;
  11.     }
  12.     public void setName(String name) {
  13.         this.name = name;
  14.     }
  15.     public int getAge() {
  16.         return age;
  17.     }
  18.     public void setAge(int age) {
  19.         this.age = age;
  20.     }
  21.     @Override
  22.     public String toString() {
  23.         return "Person{" +
  24.                 "name='" + name + '\'' +
  25.                 ", age=" + age +
  26.                 '}';
  27.     }
  28. }
复制代码
3、随机存储文件流


写进文件测试

  1.     @Test
  2.     public void test1() {
  3.         RandomAccessFile raf1 = null;
  4.         RandomAccessFile raf2 = null;
  5.         try {
  6.             raf1 = new RandomAccessFile(new File("hello.txt"),"r");
  7.             raf2 = new RandomAccessFile(new File("world.txt"),"rw");
  9.             byte[] buffer = new byte[1024];
  10.             int len;
  11.             while ((len = raf1.read(buffer))!= -1){
  12.                 raf2.write(buffer,0,len);
  13.             }
  14.         } catch (IOException e) {
  15.             throw new RuntimeException(e);
  16.         } finally {
  17.             if (raf1 !=null){
  18.                 try {
  19.                     raf1.close();
  20.                 } catch (IOException e) {
  21.                     throw new RuntimeException(e);
  22.                 }
  23.             }
  24.             if (raf2 != null){
  25.                 try {
  26.                     raf2.close();
  27.                 } catch (IOException e) {
  28.                     throw new RuntimeException(e);
  29.                 }
  30.             }
  31.         }
  32.     }
复制代码
数据插入结果实现

  1.   @Test
  2.     public void test1() throws IOException {
  3.         RandomAccessFile raf = new RandomAccessFile(new File("hello.txt"),"rw");
  4.         raf.seek(3);//将指针调到角标为3的位置
  5.         //保存指针3后面的所有数据到StringBuilder中
  6.         StringBuilder sb = new StringBuilder((int)new File("hello.txt").length());
  7.         byte[]buffer = new byte[20];
  8.         int len;
  9.         while ((len = raf.read(buffer))!= -1){
  10.             sb.append(new String(buffer,0,len));
  11.         }
  12.         //调回指针，写入xyz
  13.         raf.seek(3);
  14.         raf.write("xyz".getBytes());
  15.         //将StringBuider中的数据写入到文件中
  16.         raf.write(sb.toString().getBytes());
  17.         raf.close();
  18.     }
复制代码
4、网络编程概述

IP与端标语

    IP：唯一的标识 Internet上的计算机(通讯实体)
在Java中利用InetAddress类代表IP
IP分类：IPv4 和 IPv6； 万维网 和 局域网
  域名： www.hao123.com
本地回路地址： 127.0.0.1 对应着localhost
怎样实例化InetAddress：两个方法：getByName(String host)、getLocalHost（）
  1. public static void main(String[] args) {
  2.         try {
  3.             InetAddress inet1 = InetAddress.getByName("192.168.10.15");
  4.             System.out.println(inet1);///192.168.10.15
  6.             InetAddress inet2 = InetAddress.getByName("www.hao123.com");
  7.             System.out.println(inet2);//www.hao123.com/153.37.235.50
  9.             InetAddress inet3 = InetAddress.getByName("127.0.0.1");
  10.             System.out.println(inet3);///127.0.0.1
  11.             //获取本地地址方式2
  12.             InetAddress inet4 = InetAddress.getLocalHost();
  13.             System.out.println(inet4);
  15.             //getHostName()
  16.             System.out.println(inet2.getHostName());//www.hao123.com
  17.             //getHostAddress()
  18.             System.out.println(inet2.getHostAddress());//153.37.235.50
  19.         } catch (UnknownHostException e) {
  20.             throw new RuntimeException(e);
  21.         }
  22.     }
复制代码
  端标语：正在计算机上运行的历程
要求：差别的历程有差别的端标语
范围：被规定为一个16位的整数，0~65535
端标语和IP地址的组合得出一个网络套接字：Socket
  网络通讯


TCP

  1.     @Test
  2.     public void  client()  {
  3.         Socket socket = null;
  4.         OutputStream os = null;
  5.         try {
  6.             //创建Socket对象，指明IP与端口号
  7.             InetAddress inet = InetAddress.getByName("127.0.0.1");
  8.             socket = new Socket(inet,8899);
  9.             //获取一个输出流，用于输出数据
  10.             os = socket.getOutputStream();
  11.             //写出数据的操作
  12.             os.write("我是客户端".getBytes());
  13.         } catch (IOException e) {
  14.             throw new RuntimeException(e);
  15.         } finally {
  16.             if (os != null){
  17.                 try {
  18.                     os.close();
  19.                 } catch (IOException e) {
  20.                     throw new RuntimeException(e);
  21.                 }
  22.             }
  23.             if (socket !=null){
  24.                 try {
  25.                     socket.close();
  26.                 } catch (IOException e) {
  27.                     throw new RuntimeException(e);
  28.                 }
  29.             }
  30.         }
  31.     }
  33.     @Test
  34.     public void server(){
  35.         ServerSocket ss = null;
  36.         Socket socket = null;
  37.         InputStream is = null;
  38.         ByteArrayOutputStream baos = null;
  39.         try {
  40.             //创建服务器端的ServerSocket，指明自己的端口号
  41.             ss = new ServerSocket(8899);
  42.             //调用accept()表示接收来自客户端的socket
  43.             socket = ss.accept();
  44.             //获取输入流
  45.             is = socket.getInputStream();
  46.             //读数据
  47.             baos = new ByteArrayOutputStream();
  48.             byte[] buffer = new byte[5];
  49.             int len;
  50.             while ((len = is.read(buffer)) != -1){
  51.                baos.write(buffer,0,len);
  52.             }
  53.             System.out.println(baos.toString());
  54.         } catch (IOException e) {
  55.             throw new RuntimeException(e);
  56.         } finally {
  57.             if (baos !=null){
  58.                 try {
  59.                     baos.close();
  60.                 } catch (IOException e) {
  61.                     throw new RuntimeException(e);
  62.                 }
  63.             }
  64.             if (is !=null){
  65.                 try {
  66.                     is.close();
  67.                 } catch (IOException e) {
  68.                     throw new RuntimeException(e);
  69.                 }
  70.             }
  71.             if (socket!=null){
  72.                 try {
  73.                     socket.close();
  74.                 } catch (IOException e) {
  75.                     throw new RuntimeException(e);
  76.                 }
  77.             }
  78.             if (ss !=null){
  79.                 try {
  80.                     ss.close();
  81.                 } catch (IOException e) {
  82.                     throw new RuntimeException(e);
  83.                 }
  84.             }
  85.         }
  86.     }
复制代码
UDP

  1.     @Test
  2.     public void  sender() throws IOException {
  3.         DatagramSocket socket = new DatagramSocket();
  5.         String str = "我是UDP方式发送的数据";
  6.         byte[] data = str.getBytes();
  7.         InetAddress inet = InetAddress.getLocalHost();
  8.         DatagramPacket packet = new DatagramPacket(data,0,data.length,inet,9090);
  10.         socket.send(packet);
  11.         socket.close();
  12.     }
  14.     @Test
  15.     public void receiver() throws IOException {
  16.         DatagramSocket socket = new DatagramSocket(9090);
  17.         byte[] buffer = new byte[100];
  18.         DatagramPacket packet = new DatagramPacket(buffer,0,buffer.length);
  19.         socket.receive(packet);
  20.         System.out.println(new String(packet.getData(),0,packet.getLength()));
  21.         
复制代码
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4