javase部分重点，易出错的笔记

最新推荐文章于 2024-05-12 20:46:47 发布
最新推荐文章于 2024-05-12 20:46:47 发布
阅读量149 收藏
点赞数
分类专栏： java基础 文章标签： javase java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZhengXinMing1998/article/details/105085305
版权

1.集合详解

https://blog.csdn.net/ZhengXinMing1998/article/details/104958234

2.多线程

2.1创建多线程的方式：
①继承Thread
②实现Runnable接口
实现Runnable接口创建多线程的好处：
a.避免了单继承的局限性。
b.增强了程序的扩展性，降低了程序的耦合性（解耦)。
2.2线程同步
①同步代码块：
synchronized (this){
}
②同步方法：
public synchronized void methodName(){
//锁对象默认是this
}
③静态同步方法
public static synchronized void methodName(){
//锁对象是本类的class属性
}
④Lock锁
Lock l = new ReentrantLock();
l.lock();
…
l.unlock();
2.3线程状态
new(新建) runnable（可运行） blocked（锁阻塞） waitting（无限等待） timed waitting（计时等待） terminated（死亡状态）
2.4线程池的两种创建方式及销毁

 ExecutorService es = Executors.newFixedThreadPool(2);
        ExecutorService es2 = new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                60L, TimeUnit.SECONDS,
                new SynchronousQueue<Runnable>());
        es2.submit(new RunnableImpl());
        es2.submit(new RunnableImpl());
        es2.submit(new RunnableImpl());

        es2.shutdown();

2.4Lambda表达式

 new Thread(()-> System.out.println(Thread.currentThread().getName()+"创建了多线程")).start();

省略规则：a.小括号内参数类型可省略；
b.若小括号内有且仅有一个参，则小括号可省略；
c.若大括号有且仅有一个语句，则无论是否有返回值，都可省略大括号、returen关键字及语句分号（注意：要省略{}，return,分号必须一起省略）。
Lambda的使用前提:a.使用Lambda必须有接口，且要要求接口中有且仅有一个抽象方法。
b.使用Lambda必须具有上下文推断。也就是方法的参数或局部变量类型必须为Lambda对应的接口类型。

3.IO流

3.1字节流：

/**
 * 字节流
 * 若进行汉字传输会出现乱码
 */
public class ZiJieDemo {
    public static void main(String[] args) throws IOException {
        File file = new File("d:\\a.txt");
        FileOutputStream fos = new FileOutputStream(file);
        FileInputStream fis = new FileInputStream(file);

        /*fos.write(97);//a
        System.out.println(fis.read());//97
        System.out.println((char)fis.read());//a*/

        byte[] bytes = {65, 66, 67, 68, 69};//一次写多个字节，若写的第一个字节是正数（0-127），那么显示的时候会查询ASCII表；若为负数，那么前两个字节组成一个中文显示，查询系统默认码表（GBK）
        fos.write(bytes);
        fos.write(bytes, 0, 2);//off:数组开始索引 len:写几个字节
        System.out.println(fis.read());

       /* byte[] bytes2 = "您好".getBytes();
        System.out.println(Arrays.toString(bytes2));//[-26, -126, -88, -27, -91, -67]   UTF-8三个字节一个中文，GBK两个字节一个中文
        for (int i = 0; i <11 ; i++) {
            fos.write(bytes2);
            fos.write("\r\n".getBytes());//换行符：windows:\r\n;    linux:/n;mac:/r

        }*/

        byte[] b = new byte[1024];
        int len = 0;
        while ((len = fis.read(b)) != -1) {
            //System.out.print((char) len);
            System.out.println(new String(b,0,len));
        }

        fos.close();
        fis.close();
    }
}

3.2字符流：

**
 * 字符流
 */
public class ZuFuDemo {
    public static void main(String[] args) throws Exception {

        //testReader();
        testWriter();
        testJDK7();
        testJDK9();
    }

    /**
     * JDK9新特性：
     * try的前边可以定义流对象
     * 在try的后边（）中可直接引入流对象名称（变量名）
     * 在try代码执行完毕后，流对象也可释放掉，不用再写finally
     */
    private static void testJDK9() throws FileNotFoundException {
        FileReader fr = new FileReader("d:\\a.txt");
        try(fr){
            System.out.println((char)fr.read());
        }catch (IOException e){
            System.out.println(e);
        }
    }

    /**
     * JDK7新特性在try的后边可以增加一个（），在括号中可以定义流对象，那么这个流对象的作用域就在try中有效，
     * try中的代码执行完毕会自动把流对象释放，不用写finally
     * 格式：
     * try(定义流对象；定义流对象...){
     *      可能产生异常的代码
     * }catch(异常类变量 变量名){
     *异常的处理逻辑
     * }
     */
    private static void testJDK7() {
        try( FileReader fr = new FileReader("d:\\a.txt");){
            System.out.println((char)fr.read());
        }catch (IOException e){
            System.out.println(e);
        }

    }

    private static void testWriter(){

        //若文件不存在，会自动创建b.txt
        FileWriter fw = null;//append:续写开关。true:不会创建新的文件覆盖原文件，可续写；false:创建新的文件覆盖原文件
        try {
            fw = new FileWriter("d:\\b.txt",true);
            //fw.write(97);
            char[] c ={'a','b','c','d'};
            fw.write(c);
            fw.write(c,1,2);
            fw.write("\r\n");
            fw.write("ABCD");
            fw.write("ABCD",0,3);

            fw.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fw!=null){
                try {
                    fw.close();//释放资源，会先把内存缓冲区中的数据刷新到文件中
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private static void testReader() throws Exception {
        FileReader fr = new FileReader("d:\\a.txt");
        System.out.println((char)fr.read());

        int len = 0;
        char[] c = new char[1024];
        while ((len=fr.read(c)) != -1){
            System.out.println(new String(c,0,len));
        }
    }

}

3.3拷贝

/**
 * 复制文件
 */
public class CopyDemo {
    public static void main(String[] args) throws Exception {
        //ziJieCopy();//若进行汉字传输会出现乱码
        ziFuCopy();//只适合拷贝文本文件，拷贝图片，音乐等会出错
    }

    private static void ziFuCopy() {
        try (FileReader reader = new FileReader("d:\\2.jpg"); FileWriter writer = new FileWriter("d:\\3.jpg")){
            char[] c = new char[1024];
            int len = 0;
            while ((len=reader.read(c)) != -1){
                writer.write(c,0,len);
            }
        }catch (Exception e){
            e.printStackTrace();
        }

    }

    private static void ziJieCopy() {
        try(FileInputStream fis = new FileInputStream("d:\\1.jpg"); FileOutputStream fos = new FileOutputStream("d:\\2.jpg");){
            byte[] b = new byte[1024];
            int len = 0;
            while ((len = fis.read(b)) != -1){
                fos.write(b,0,len);
            }
        }catch (Exception e){
            e.printStackTrace();
        }

        //JDK7新特性trycatch后会自动关流
        //fis.close();
        //fos.close();
    }
}

3.4属性集
①Properties 类(HashTable的子类，表示了一个持久的属性集，Properties可保存在流中或从流中加载，属性列表中每个键及其对应值都是一个字符串。)
②Properties集合是一个唯一和IO流相结合的集合。
可使用Properties集合中的方法store，把集合中的临时数据持久化写入到硬盘中存储；
可使用load方法，把硬盘中保存的文件（键值对）读取到集合中使用；

public class Demo01Properties {
    public static void main(String[] args) {
        show03();
    }

    private static void show03() {
        Properties prop = null;
        try (FileReader fr = new FileReader("d:\\prop.txt")){
           prop = new Properties();
           prop.load(fr);
           //遍历properties集合
            Set<String> set = prop.stringPropertyNames();//返回此属性列表中的键集,相当于map集合中的keySet方法
            for (String key : set) {
                String value = prop.getProperty(key);
                System.out.println(key + "=" + value);
            }

        }catch (Exception e){
            e.printStackTrace();
        }
    }

    private static void show01() {
        Properties prop = new Properties();
        prop.setProperty("熊大", "12");
        prop.setProperty("熊二", "11");
        prop.setProperty("光头强", "22");
        prop.setProperty("翠花", "10");

        Set<String> set = prop.stringPropertyNames();//返回此属性列表中的键集,相当于map集合中的keySet方法
        for (String key : set) {
            String value = prop.getProperty(key);
            System.out.println(key + "=" + value);
        }
    }

    private static void show02() {
        Properties prop = new Properties();
        prop.setProperty("熊大", "12");
        prop.setProperty("熊二", "11");
        prop.setProperty("光头强", "22");
        prop.setProperty("翠花", "10");

        //创建字节/字符输出流对象，构造方法中绑定要输出的目的地
        //使用Properties集合中的方法store，把集合中的临时数据持久化写入到硬盘中存储；
        try(FileWriter fw = new FileWriter("d:\\prop.txt"); FileOutputStream fos = new FileOutputStream("d:\\prop.txt");) {
            prop.store(fw,"zifuliu");//comments:注释
            //prop.store(fos,"zijieliu");//会覆盖上面的
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.5缓冲流

public class BufferedDemo {
    public static void main(String[] args) {
        //show1();
        show02();
    }

    private static void show02() {
        try (FileReader fr = new FileReader("d:\\3.txt");
             FileWriter fw = new FileWriter("d:\\4.txt");
             BufferedReader br = new BufferedReader(fr);
             BufferedWriter bw = new BufferedWriter(fw);) {
            /*bw.write("吉吉国王");
            bw.newLine();//换行
            bw.write("吉吉国王");
            System.out.println(br.readLine());*/

            /*int len = 0;
            char[] c = new char[1024];
            while ((len=br.read(c))!=-1){
                bw.write(c,0,len);
            }*/
            String line;
            while ((line=br.readLine())!=null){
                bw.write(line);
                bw.newLine();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private static void show1() {
        try (FileInputStream fis = new FileInputStream("d:\\1.txt");
             FileOutputStream fos = new FileOutputStream("d:\\2.txt");
             BufferedInputStream bis = new BufferedInputStream(fis);
             BufferedOutputStream bos = new BufferedOutputStream(fos)
             ) {
            //bos.write("郑新明".getBytes());
            byte[] b = new byte[1024];
            int len = 0;
            while ((len = bis.read(b)) != -1) {
                System.out.println(len);
                bos.write(b, 0, len);
            }

            //System.out.println(bis.read());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

3.6转换流

/**
 *将GBK编码的文本文件转换为UTF-8编码的文本文件
 */
public class TransDemo {
    public static void main(String[] args) throws IOException {
        InputStreamReader reader = new InputStreamReader(new FileInputStream("d:\\GBK.txt"),"GBK");
        OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream("d:\\UTF-8.txt"),"UTF-8");
        //writer.write("你好");
        char[] c = new char[1024];
        int len = 0;
        while ((len=reader.read(c)) != -1){
            writer.write(c,0,len);
        }

        writer.close();
        reader.close();
    }
}

3.7序列化(被transient关键字修饰的变量不再能被序列化，一个静态变量不管是否被transient修饰，均不能被序列化。)

/**
 * static关键字：静态关键字
 *              静态优先于非静态加载于内存中，被static修饰的成员变量不能被序列化，序列化的都是对象
 *transient关键字：瞬态关键字
 *              被transient修饰的成员变量不能被序列化（无静态含义）
 */
public class XuLieHuaDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //objectCopyTest();
        objectListCopyTest();
}

    private static void objectListCopyTest() throws IOException, ClassNotFoundException {
        ArrayList<Person> list = new ArrayList<>();
        list.add(new Person("熊二",11));
        list.add(new Person("熊二",11));
        list.add(new Person("熊二",11));
        list.add(new Person("熊二",11));

        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:\\list.txt"));
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("d:\\list2.txt"));
        oos.writeObject(list);
//        System.out.println(ois.readObject());
        oos.writeObject(ois.readObject());

        oos.close();
        ois.close();
    }

    private static void objectCopyTest() throws IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:\\person.txt"));
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("d:\\person2.txt"));
        oos.writeObject(new Person("熊大",12));
//        System.out.println(ois.readObject());
        oos.writeObject(ois.readObject());

        oos.close();
        ois.close();
    }
}

4.网络编程

网络通信协议

public class TCPClient {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("192.168.25.1", 8888);
        OutputStream outputStream = socket.getOutputStream();//网络字节输出流
        outputStream.write("你好，服务器".getBytes());

        InputStream inputStream = socket.getInputStream();
        byte[] bytes = new byte[1024];
        int len = 0;
        while ((len = inputStream.read(bytes)) != -1){
            System.out.println(new String(bytes,0,len));
        }

        socket.close();
    }
}

public class TCPServer {
    public static void main(String[] args) throws IOException {
        ServerSocket server = new ServerSocket(8888);
        Socket socket = server.accept();

        InputStream inputStream = socket.getInputStream();
        byte[] bytes = new byte[1024];
        int len = 0;
        while ((len = inputStream.read(bytes)) != -1){
            System.out.println(new String(bytes,0,len));
        }

        OutputStream outputStream = socket.getOutputStream();//网络字节输出流
        outputStream.write("收到谢谢，你好客户端".getBytes());

        socket.close();
        server.close();
    }
}

public class FileUploadTCPClient {
    public static void main(String[] args) throws IOException {
        //复制文件到服务器
        FileInputStream fis = new FileInputStream("d:\\a.txt");
        Socket socket = new Socket("192.168.25.1",8888);
        OutputStream os = socket.getOutputStream();

        byte[] bytes = new byte[1024];
        int len = 0;
        while ((len=fis.read(bytes)) != -1){
            os.write(bytes,0,len);
        }
        socket.shutdownOutput();//（禁用此套接字的输出流）上传完文件，给服务器一个结束标记，解决阻塞问题

        //读取服务器回写的数据
        InputStream is = socket.getInputStream();
        while ((len = is.read(bytes)) != -1){
            System.out.println(new String(bytes,0,len));
        }

        socket.close();
        fis.close();
    }
}

public class FileUploadTCPServer {
    public static void main(String[] args) throws IOException {
        //接收客户端上传的文件
        ServerSocket serverSocket = new ServerSocket(8888);
        /**
         * 让服务器一直处于监听状态（死循环accept方法）
         */
        while (true){
            Socket socket = serverSocket.accept();
            /**
             * 使用多线程技术，提高程序效率
             * 有一个客户端上传文件，就开启一个线程，完成文件的上传
             */
            new Thread(()->{
                try {
                    InputStream is = socket.getInputStream();
                    File file = new File("e:\\upload");
                    if (!file.exists()){
                        file.mkdirs();
                    }
                    /**
                     * 自定义一个文件命名规则，防止同名的文件被覆盖
                     */
                    String fileName ="zxm"+System.currentTimeMillis()+ new Random().nextInt(999999)+".txt";

                    FileOutputStream fos = new FileOutputStream(file+"\\"+fileName);

                    int len = 0;
                    byte[] bytes = new byte[1024];
                    while ((len=is.read(bytes)) != -1){
                        fos.write(bytes,0,len);
                    }

                    //回写数据给客户端
                    OutputStream os = socket.getOutputStream();
                    os.write("上传成功".getBytes());

                    socket.close();
                    fos.close();
                }catch (IOException e){
                    e.printStackTrace();
                }

            }).start();
        }
        //serverSocket.close();
    }
}

*代码执行顺序：
在这里插入图片描述

silence_zheng
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
javase部分 重点知识笔记
10-06
某机构听课实记，从Java面向对象到反射部分，通过大量图文辅助记忆，可以迅速搭建思维逻辑，这是第一部分，有完整笔记。图文丰富，共16章，欢迎交流分享（需要源码可私）
Java中关于最简单的输入输出字节流操作
jjb_584520的博客
11-01 1498
Java中关于文件的读入和写出
Java字节数组byte b[]与byte[] b
allway2的博客
12-25 4万+
Java中的字节数组 Java字节数组仅用于存储字节数据类型值。字节数组中元素的默认值为0。 通过以下Java字节数组示例，您可以学习 如何声明Java字节数组？ 如何为Java字节数组分配值？ 如何从Java字节数组获取值？ 如何在Java中将String转换为字节数组？ 如何在Java中将字节数组转换为字符串？ 什么是字节？ 一组二进制数字或位（通常是八个）作为一个单元进行操作。一个字节，视为内存大小的单位。 字节是数字信息的单位，通常由八位组成。从历史上看，字节是计算机中用于编码文本
Java编程拾遗『字节流』
卓立的博客
08-14 399
上篇文章中简单介绍了文件和Java IO的概念，我们了解到Java中文件是作为一种特殊的IO设备处理的，并且Java中处理IO是通过流来操作的，流又可以细分为字节流和字符流。本篇文章就重点介绍一下Java IO中的一个重要模块——字节流。字节流的继承体系如下图所示： 本文重点介绍如下几种字节流： InputStream/OutputStream: 基类，抽象类。 ByteArrayInp...
Java基于byte length参数生成易于理解的文件大小
筱光的博客
05-15 1413
commons-io工具类FileUtils中有一个方法，FileUtils.byteCountToDisplaySize => 以可读的方式，返回文件的大小EB, PB, TB, GB, MB, KB or bytes，但是该方法返回的是整数，如果满足需求可直接用，本人觉得保留两位小数在实际应用中更合理一些，因此在系统中新增FileUtils类，重写该方法。 package cn.aresoft.common.util.file; import java.math.BigDecimal; i.
java byte 与操作_Java Byte 操作
weixin_42360953的博客
02-16 217
publicclassByteUtil{/***ConvertaStringofhexadecimaldigitsintothecorrespondingbytearray*byencodingeachtwohexadecimaldigitsasabyte.**@paramdigits*Hexadecimaldigitsrepr...
黑马程序员Javase笔记
01-18
正在自学黑马程序员Java全套，目前只学了Javase，接下来是Javaweb，把自己整理的笔记分享一下。
javase笔记
01-24
javase笔记，非常有用的java学习资料，多年积累的java
非常详细javaSE学习笔记.rar
10-21
从java历程开始到javaSE出道，涉猎到了javaSE所有的知识点，里面不仅有知识点笔记还有练习源码例子以及相关资料和PPT等。非常实用值得你拥有
JavaSE 李兴华主讲的全套笔记
09-04
包括李新华javase视频讲解时所有的内容，非常全面，非常适合java的初学者。
1.2w+字！Java IO 基础知识总结
程序员小明1024
09-18 230
IO 流简介 IO 即Input/Output，输入和输出。数据输入到计算机内存的过程即输入，反之输出到外部存储(比如数据库，文件，远程主机)的过程即输出。数据传输过程类似于水流，因此称为 IO 流。IO 流在 Java 中分为输入流和输出流，而根据数据的处理方式又分为字节流和字符流。 Java IO 流的 40 多个类都是从如下 4 个抽象类基...
在Java中按字节获得字符串长度的两种方法
DreamRemaiN的专栏
05-22 2655
本文为转载，转载地址：http://www.blogjava.net/nokiaguy/archive/2010/04/11/317982.html     由于Java是基于Unicode编码的，因此，一个汉字的长度为1，而不是2。但有时需要以字节单位获得字符串的长度。例如，“123abc长城”按字节长度计算是10，而按Unicode计算长度是8。为了获得10，需要从头扫描根据字符的As...
Socket笔记之Read timed out深入分析
热门推荐
jannal专栏
09-10 11万+
ReadTimedOut深入分析 PlainSocketImpl.c Java_java_net_PlainSocketImpl_socketSetOption read()时 Java_java_net_SocketInputStream_socketRead0 solaris/native/java/net/bsd_close.c 总结 ReadTimedOut...
Java文件字节输入流的使用
qq_45659397的博客
08-20 669
Java文件字节输入流的使用
黑马程序员第六季——网络（Socket编程）
qq214347357的专栏
02-01 541
网络基本知识： 在java中网络程序有两种协议：TCP和UDP，TCP通过握手协议进行可靠的连接，UDP则是不可靠连接。 IP地址：用于标记一台计算机的身份证。 IP地址由网络地址（确定网络）和主机地址（网络中的主机）组成。 子网掩码：为了区分网络地址和主机地址。 IP地址分为A类地址、B类地址、C类地址（常用）、D类地址、E类地址。 127.0.0.1（loc
jdk8新特性----Lambda表达式
w_t_y_y的博客
05-11 186
Java的Lambda表达式是Java 8引入的一个特性，它支持函数式编程，允许将函数作为方法的参数或返回值，从而简化了匿名内部类的使用，并提供了对并行编程的更好支持。
java jar包如何运行或调用
NLP与推荐算法
05-08 255
java服务启动
CMS垃圾回收器为什么被移除
m0_54187478的博客
05-10 342
由于上述缺点，加上需要将资源投入到更现代垃圾回收器的开发和优化上，Oracle决定从Java 9开始标记CMS为废弃，并在后续版本中完全移除CMS。这些新的收集器旨在提供更低的停顿时间和更高的性能，同时减少配置和维护的复杂性。当它在垃圾收集周期内无法足够快地回收内存时，会退回到一种需要完全暂停所有应用线程的老年代收集模式，这与它设计的初衷相违背。：CMS使用的标记-清除算法会导致较多的内存碎片。：CMS需要更多的CPU资源来执行垃圾回收的并发阶段，而且它在运行时对系统资源的利用也较为激进。
Redis的数据淘汰策略——Java全栈知识（19）
最新发布
dghehe的博客
05-12 272
数据过期策略是 redis 中设置了 TTL 的数据过期的时候 Redis 的处理策略。数据淘汰策略是 Redis 内存不够的时候，数据的淘汰策略：当 Redis 中的内存不够用时，此时在向 Redis 中添加新的 key, 那么 Redis 就会按照某一种规则将内存中的数据删除掉，这种数据的删除规测被称之为内存的淘汰策略。redis 的内存删除策略有：·noeviction: 不会淘汰任何键值对，而是直接返回错误信息。
javase黑马笔记
08-16
很抱歉，根据提供的引用内容，无法回答关于"javase黑马笔记"的问题。请提供更具体的问题或信息，以便我可以为您提供更准确的答案。<span class="em">1</span><span class="em">2</span><span class="em">3 #### 引用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值