Java 学习笔记(手写版)
 


 
文章目录
 
Java 学习笔记(手写版)
变量
控制流程
包机制 & 用户交互 Scanner
方法（函数） & 驼峰命名法
递归 & 数组
OOP & 构造器
封装
继承 （super & this）
方法重写 静态方法 & 非静态方法
多态 & instance of & 类型转换
static 关键字
抽象类
接口 & 实现类
内部类
正则表达式
异常
注解
  
反射//..
多线程
基本概念
线程创建
静态代理模式 & 函数式接口 & Lambda 表达式
线程状态
线程方法
线程优先级
守护线程 & 线程同步 synchronized
同步方法及同步块
死锁
锁Lock
  
  
线程协作 生产者消费者//..
线程池
   
常用类
String类
包装类
自动拆箱 & 装箱
    
Date 时间类
Calendar 日历类
Math 类
File 类
枚举
   
容器 Collection（集合）
泛型
Collection 接口
List 接口
ArrayList
    
Map 接口
HashMap底层原理
TreeMap
    
Set 接口
  
  
TreeSet 使用和底层原理 / /
Iterator 迭代器的使用——遍历List、Set、Map
Collections 工具类 常用方法
   
IO 流
分类 & 四大家族
流的基本框架
FileInputStream
FileOutputStream
文件复制
FileReader & FileWriter
BufferedReader
InputStreamReader
DataOutputStream & DataInputStream
PrintStream
日志工具
   
  
 

 
变量
 

 
 
控制流程
 

 
 
包机制 & 用户交互 Scanner
 
 
方法（函数） & 驼峰命名法
 
 

 
 
递归 & 数组
 
 
OOP & 构造器
 
 
封装
 
 
继承 （super & this）
 
 
方法重写 静态方法 & 非静态方法
 
 
多态 & instance of & 类型转换
 

 
 
 
static 关键字
 

 
 
抽象类
 
 
接口 & 实现类
 
 
内部类
 

 
 
正则表达式
 

 
 
 
异常
 

 
 
注解
 

 
 
 
反射//…
 
多线程
 
基本概念
 
 
线程创建
 

 
 
静态代理模式 & 函数式接口 & Lambda 表达式
 
 
线程状态
 
 
线程方法
 

 
 
 
 
线程优先级
 
 
守护线程 & 线程同步 synchronized
 
 
同步方法及同步块
 
 
死锁
 
 
锁Lock
 
 
线程协作 生产者消费者//…
 
 
线程池
 
 
常用类
 
String类
 

 
 
 
包装类
 
 
自动拆箱 & 装箱
 
 
Date 时间类
 
 
Calendar 日历类
 
 
Math 类
 
 
File 类
 
 
枚举
 
 
容器 Collection（集合）
 
泛型
 
 
Collection 接口
 
 
List 接口
 
 
ArrayList
 

 
 
Map 接口
 
 
 
HashMap底层原理
 

 
 

 
 
 
TreeMap
 
 
Set 接口
 
 
TreeSet 使用和底层原理 / /
 
 
Iterator 迭代器的使用——遍历List、Set、Map
 

 
 
 
Collections 工具类 常用方法
 
 
IO 流
 
分类 & 四大家族
 

 
 
 
流的基本框架
 
 
FileInputStream
 

 
 
FileOutputStream
 
 
文件复制
 
 
FileReader & FileWriter
 
 
BufferedReader
 
 
InputStreamReader
 
 
DataOutputStream & DataInputStream
 

 
 
PrintStream
 
 
日志工具
 

 
并发编程难学吗？
 
首先，难是肯定的。因为这其中涉及操作系统、CPU、内存等等多方面的知识，如果你缺少某一块，那理解起来自然困难。其次，难不难学也可能因人而异，就我的经验来看，很多人在学习并发编程的时候，总是喜欢从点出发，希望能从点里找到规律或者本质，最后却把自己绕晕了。
 
为了让你的知识更成体系，融会贯通，最终能够得心应手地解决各种并发难题，同时将这些知识用于其他编程语言，今天小编给大家推荐一套并发编程全家桶资料。
 
含括了四个PDF文档和面试题，真的真的真的很不错！
 

 
在这里插入图片描述
 
文档一：并发编程
 
主目录：
 

 
在这里插入图片描述
 
1. 概览
 

 
在这里插入图片描述
 
2. 进程与线程
 
本章内容：进程和线程的概念、并行和并发的概念、线程基本应用
 

 
在这里插入图片描述
 
3. Java 线程
 
本章内容：创建和运行线程、查看线程、线程 API、线程状态
 

 
在这里插入图片描述
 
4. 共享模型之管程
 
本章内容：共享问题、synchronized、线程安全分析、Monitor、wait/notify、线程状态转换、活跃性、Lock
 

 
在这里插入图片描述
 
5. 共享模型之内存本章内容
 
上一章讲解的 Monitor 主要关注的是访问共享变量时，保证临界区代码的原子性
 
这一章我们进一步深入学习共享变量在多线程间的【可见性】问题与多条指令执行时的【有序性】问题
 

 
在这里插入图片描述
 
6. 共享模型之无锁
 
本章内容：CAS 与 volatile、原子整数、原子引用、原子累加器、Unsafe
 

 
在这里插入图片描述
 
7. 共享模型之不可变
 
本章内容：不可变类的使用、不可变类设计、无状态类设计
 

 
在这里插入图片描述
 
8. 共享模型之工具
 

 
在这里插入图片描述
 
文档二：并发编程——模式篇
 

 
在这里插入图片描述
 
文档三：并发编程——应用篇
 

 
在这里插入图片描述
 
文档三：并发编程——原理篇
 

 
在这里插入图片描述
 
文档四：面试篇
 

 
在这里插入图片描述
 

 
在这里插入图片描述
 
介绍完毕
 
压缩如下：
 

 
在这里插入图片描述
 
写在最后
 
由于篇幅原因，有需要并发编程全家桶完整文档的麻烦+QQ：(3368213683)或交流群：(328993819)，备注简书，免费获取。

 
我有数百张手写笔记的图像。它们是由不同的人编写的，但是它们是按顺序排列的，因此您知道例如person1编写了img1.jpg-> img100.jpg。手写样式因人而异，但笔记的某些部分始终是固定的，我想这可以帮助一种算法(对我有帮助！)。
 
我尝试了tesseract，但它在识别文本方面非常失败。我在想，因为每个人都有100张图像，是否有一种算法可以通过提供少量示例(例如5个或更少)来进行训练，并且可以从中学习？还是数据不足？从周围搜索看来，我似乎需要实现CNN(例如this paper)。
 
我对ai的了解有限，这是我仍然可以使用图书馆和一些学习方法吗？如果是这样，我应该怎么做？
 
参考方案
 
这称为OCR，并且已经取得了进展。实际上，这是一个使用tesseract将图像文件解析为文本的过程的简单示例：
 
try:
 
from PIL import Image
 
except ImportError:
 
import Image
 
import pytesseract
 
def ocr_core(file):
 
text = pytesseract.image_to_string(file)
 
return text
 
print(ocr_core('sample.png'))
 
但
 
我不太确定它能否识别不同类型的笔迹。您可以自己尝试一下以找出答案。如果要尝试python示例，则需要导入tesseract，但首先要在操作系统上安装tesseract并将其添加到PATH中。
 
Java:找到特定字符并获取子字符串 - java
 
我有一个字符串4.9.14_05_29_16_21，我只需要获取4.9。数字各不相同，所以我不能简单地获得此char数组的前三个元素。我必须找到最正确的.并将其子字符串化直到那里。我来自Python，因此我将展示Python的实现方法。def foobar(some_string): location = some_string.rfind('.&…java:继承 - java
 
有哪些替代继承的方法？ java大神给出的解决方案 有效的Java：偏重于继承而不是继承。 (这实际上也来自“四人帮”)。他提出的理由是，如果扩展类未明确设计为继承，则继承会引起很多不正常的副作用。例如，对super.someMethod()的任何调用都可以引导您通过未知代码的意外路径。取而代之的是，持有对本来应该扩展的类的引用，然后委托给它。这是与Eric…Java:BigInteger，如何通过OutputStream编写它 - java
 
我想将BigInteger写入文件。做这个的最好方式是什么。当然，我想从输入流中读取(使用程序，而不是人工)。我必须使用ObjectOutputStream还是有更好的方法？目的是使用尽可能少的字节。谢谢马丁 参考方案 Java序列化(ObjectOutputStream / ObjectInputStream)是将对象序列化为八位字节序列的一种通用方法。但…Java-如何将此字符串转换为日期？ - java
 
我从服务器收到此消息，我不明白T和Z的含义，2012-08-24T09:59:59Z将此字符串转换为Date对象的正确SimpleDateFormat模式是什么？ java大神给出的解决方案 这是ISO 8601标准。您可以使用SimpleDateFormat simpleFormat = new SimpleDateFormat("yyyy-MM…Java:从类中查找项目名称 - java
 
仅通过类的实例，如何使用Java反射或类似方法查找项目名称？如果不是，项目名称(我真正想要的是)可以找到程序包名称吗？ 参考方案 项目只是IDE使用的简单组织工具，因此项目名称不是类或JVM中包含的信息。要获取软件包，请使用Class#getPackage()。然后，可以调用Package#getName()将包作为您在代码的包声明中看到的String来获取…

背包问题
 
题目
 
有 N 件物品和一个容量是V 的背包。每件物品只能使用一次。
 
第 ii 件物品的体积是 vi，价值是 wi。
 
求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
 输出最大价值。
 
输入格式
 
第一行两个整数，N,V，用空格隔开，分别表示物品数量和背包容积。
 
接下来有 N行，每行两个整数 vi,wi，用空格隔开，分别表示第 ii 件物品的体积和价值。
 
输出格式
 
输出一个整数，表示最大价值。
 
数据范围
 
0<N,V≤10000<N,V≤1000
 0<vi,wi≤10000<vi,wi≤1000
 
输入样例
 
4 5
1 2
2 4
3 4
4 5
 
输出样例：
 
8
 
 
朴素解法(输入输出版)
 
/**
 *  @see Acwing 01背包问题 https://www.acwing.com/problem/content/2/
 */

import java.util.Scanner;

public class o1bagIOClass {
    static int N = 1010;
    static int n,bagVolume;
    static int[]volume  = new int[N];
    static int[]worth = new int[N];
    static int[][] dp = new int[N][N];

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n  =sc.nextInt();
        bagVolume = sc.nextInt();
        //一定要注意，输入输出版的背包问题，2个数组都是从第二个数开始填入的
        for(int i = 1; i <= n; i++) {
            volume[i] = sc.nextInt();
            worth[i] = sc.nextInt();
        }

        for(int i = 1; i <= n; i++) {
            for(int j = 1; j <= bagVolume; j++) {
                dp[i][j] = dp[i-1][j];
                if (j>=volume[i]){
                    dp[i][j] = Math.max(dp[i][j],dp[i-1][j-volume[i]]+worth[i]);
                }
            }
        }
        System.out.println(dp[n ][bagVolume]);
    }

}

 
朴素解法(函数版)
 

import java.util.Scanner;

public class o1bagClass {
    public static int o1bagSolution(int[] weight, int[] value, int bagWeight) {
        int num = weight.length;
        int[][] dp = new int[num + 1][bagWeight + 1];
        //注意函数版本的背包；2个数组都是从第一个数开始填入的，所以状态转移方程有所差别
        for (int i = 1; i <= num; i++) {
            for (int j = 0; j <= bagWeight; j++) {
                dp[i][j] = dp[i - 1][j];
                if (j >= weight[i - 1]) {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - weight[i - 1]] + value[i - 1]);
                }
            }
        }
        return dp[num][bagWeight];
    }


    public static void main(String[] args) {
        int[] weight ={2,3,4,5};
        int[] value = {3,4,5,6};
        System.out.println(o1bagSolution(weight,value,8));

  }

}

 
空间优化解法(输入输出版)
 
/**
 * @see Acwing 01背包问题 https://www.acwing.com/problem/content/2/
 */

import java.util.Scanner;

public class o1bagOptimizationClass {
    /**
     * n 为物品的数量
     * bagVolume 为背包的体积
     * volume[] 存储每个物品的体积
     *  worth[] 存储每个物品的价值
     */
    static int N = 1010;
    static int n, bagVolume;
    static int[] volume = new int[N];
    static int[] worth = new int[N];
    static int[] dp = new int[N];

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        bagVolume = sc.nextInt();
        //一定要注意，输入输出版的背包问题，2个数组都是从第二个数开始填入的
        for (int i = 1; i <= n; i++) {
            volume[i] = sc.nextInt();
            worth[i] = sc.nextInt();
        }

        for (int i = 1; i <= n; i++) {
            //dp[i][j] = dp[i-1][j];优化过后为恒等式，直接去掉
            for (int j = bagVolume; j >= volume[i]; j--) {
                //if语句合并入for循环内
                //dp[i][j] = Math.max(dp[i][j],dp[i-1][j-volume[i]]+worth[i]);
                //优化掉一维后为dp[j] = Math.max(dp[j],dp[j-volume[i]]+worth[i]);
                //因为dp[j] 必须比 dp[j-volume[i]] 要后计算出，所以采用倒序遍历
                dp[j] = Math.max(dp[j], dp[j - volume[i]] + worth[i]);
            }
        }
        System.out.println(dp[bagVolume]);
    }
}

 
空间优化解法(函数版)
 

import java.util.Scanner;

public class o1bagClass {
    public static int o1bagSolutionOptimization
            (int[] volume, int[] worth, int bagWeight) {
        int num = volume.length;
        int[] dp = new int[bagWeight + 1];

        for (int i = 1; i <= num; i++) {
            for (int j = bagWeight; j >= volume[i - 1]; j--) {
                    dp[j] = Math.max(dp[j], dp[j - volume[i - 1]] + worth[i - 1]);
            }
        }
        return dp[bagWeight];
    }
  
    public static void main(String[] args) {
        int[] weight ={2,3,4,5};
        int[] value = {3,4,5,6};
        System.out.println(o1bagSolutionOptimization(weight,value,8));

}

}

 
代码优化版(边输入边处理)
 
import java.util.Scanner;
public class o1bagOptimizationPlusIOClass {
    static int N = 1010;
    static int[] dp = new int[N];
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n  =sc.nextInt(), bagVolume = sc.nextInt();
        //一定要注意，输入输出版的背包问题，2个数组都是从第二个数开始填入的
        for(int i = 1; i <= n; i++) {
            int volume,worth;
            volume = sc.nextInt(),worth = sc.nextInt();
            for (int j = bagVolume; j >=volume ; j--) dp[j] = Math.max(dp[j], dp[j-volume]+worth);  
        }
        System.out.println(dp[bagVolume]);
    }
}

 
 

 
 
 
下一篇：(完全背包问题(Java)