周学习总结

一、所学内容

（1）异常

定义：异常就是代表程序出现的问题

Java.lang.Throeable

Error:代表的系统级别错误（属于严重为题，Error是给Sun公司自己用的）

Exception:异常体系的最上层父类，通常用Exception以及他的子类来存储异常

异常分为两类：编译时异常、运行时异常

编译时异常：没有继承RuntimeException的异常，直接继承于Exception。编译阶段就会错误提示。

运行时异常：RuntimeException本身和子类。

作用：

1.异常用来查询bug的关键参考信息

2.异常作为方法内部的一种特殊返回值，以便同值调用者底层的执行情况

处理方式：

1.JVM默认的处理方式

将异常名称，原因以及出现的位置打印在控制台；程序停止执行。

2.自己处理

（1）try{ 可能出现异常的代码；}

catch（ArrayIndexOutOfBoundsException(异常问题) e)

{如果出现了ArrayIndexOutOfBoundsException异常，该如何处理；}

如果try中可能遇到多个问题，那么一个问题对应一个catch（），如果要捕获多个异常，如果异常中存在父子关系，那么父类一定要写在下面。

打印错误的语句（用来打印错误信息）

例：System.err.println（）

3.抛出异常

throws：写在方法定义处，表示声明一个异常，告诉调用者，使用本方法可能会有哪些异常

格式：

throw：写在方法内，结束方法，手动抛出异常对象，交给调用者，方法中下面的代码不再执行了

格式：

（2）File

delete方法默认只能删除违建和空文件夹，delete方法直接删除不走回收站。

；如果删除的是空文件夹，直接删除不走回收站；如果是有内容的文件夹，删除不了。

creatNewFile（）：如果当前路径文件不存在，就创建成功，否则失败；

如果父级路径是不存在的，那么方法就会有一场IOException；

此方法创建的一定是文件没如果路径中不包含后缀名，则创建一个没有后缀的文件。

mkdir（）：智能创建单级文件夹，不能创建多级文件夹

当调用者File表示的路径是需要权限才能访问的文件夹时，返回null。

（3）IO流：存储和读取数据的解决方案

FileOutputStream：操作本地文件的字节输出流，可以把程序中的数据写到本地文件中。

书写步骤：1.创建字节输出流对象

参数是字符串中表示的路径或者是File对象；如果文件不存在会创建一个新文件，但是要保证父级路径是存在的；如果文件已经存在，会清空文件内容。

2.写数据

write方法的参数是整数，但实际上写到本地文件中的是整数在ASCII上对应的字符

3.释放资源

文件写入：文件名.write()

文件释放：文件名.close()

写数据三种方式：

换行和续写：

换行：windows：\r\n ； Linux：\n ；Max:\n

在windows操作系统中，java对回车换行进行了优化，虽然完整的是\r\n，但是我们写其中一个\r或者\n，java也可以实现换行，但最好还是全写。

续写：如果需要续写，打开续写开关即可；

开关位置：创建对象的第二个参数；默认false：表示关闭续写，此时创建对象会清空文件；手动传递true：表示打开续写，此时创建对象不会清空文件。

FileInputStream：操作本地文件的字节输入流，可以把本地文件中的数据读取到程序中来。

书写步骤：

1.创建字节输入流对象

如果文件不存在，直接报错

2.读数据

文件名.read()；

一次读一个字节，读出来的是数据在ASCII中对应的数字；

读到文件末尾了read方法返回-1；

3.释放资源

文件拷贝：

利用 try...catch...finally捕获拷贝文件中代码出现的异常

自动释放资源：AutoCloseable（）；

字符集：

GB 2312字符集：

GBK字符集：windows系统默认使用就是GBK。系统显示ANSI。

Unicode字符集：国际标准字符集。

英文储存规则：utf-16编码规则：2-4个字节保存

utf-32：固定4个字节保存

utf-8：用1-4个字节保存（ASCII：1个字节，简体中文：3个字节）

字符流=字节流+字符集

操作本地文件的字符输入流：FileReader

操作本地文件的字符输出流：FileWriter

read()细节：

1.read（）：默认也是一个字节一个字节的读取的，如果遇到中文就会一次读取多个

2.在读取之后，方法的底层还会进行解码并转换成十进制，最终将十进制作为返回值，这个十进制的数据也表示在字符集上的数字。

3.想看到文件中的文字，就将十进制数据进行强制转换为char型。

FileWriter

字节流和字符流的使用场景

字节流：拷贝任意类型的文件

字符流：读取纯文本文件中的数据，往纯文本文件中写出数据。

（4）对所学内容不理解的地方：

<1> 文件加密和解密原理

解决：将代码自己敲击一遍，然后足部进行代码运算，了解到进行加密方式是对文件存储数据的更改，解密就是对文件数据的还原。

二、力扣刷题

7. 整数反转

中等

3.9K

相关企业

给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。

如果反转后整数超过 32 位的有符号整数的范围 [−231,  231 − 1] ，就返回 0。

假设环境不允许存储 64 位整数（有符号或无符号）。

示例 1：

输入：x = 123
输出：321

示例 2：

输入：x = -123
输出：-321

示例 3：

输入：x = 120
输出：21

示例 4：

输入：x = 0
输出：0

提示：

• -2^31 <= x <= 2^31 - 1

class Solution {
    public int reverse(int x) {
             String str;
             int flag=0;
            long  nums=0;
            str=String.valueOf(x);
            for(int i=str.length()-1;i>=0;i--)
            {
                char ch=str.charAt(i);
                if(ch=='-') 
                   flag=-1;
                else 
                   nums=nums*10+(int)(ch-'0');
                                 
            }
            if(flag!=0)
            {
               nums=nums*flag;
            }
                if(nums>=Integer.MIN_VALUE&&nums<Integer.MAX_VALUE-1)
                      return  (int)nums;
               return 0;
    }
}

4. 寻找两个正序数组的中位数

困难

6.8K

相关企业

给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。

算法的时间复杂度应该为 O(log (m+n)) 。

示例 1：

输入：nums1 = [1,3], nums2 = [2]
输出：2.00000
解释：合并数组 = [1,2,3] ，中位数 2

示例 2：

输入：nums1 = [1,2], nums2 = [3,4]
输出：2.50000
解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5

提示：

• nums1.length == m
• nums2.length == n
• 0 <= m <= 1000
• 0 <= n <= 1000
• 1 <= m + n <= 2000
• -10^6 <= nums1[i], nums2[i] <= 10^6

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
       int[] c=new int[nums1.length+nums2.length];
      for(int i=0;i<nums1.length;i++)
       c[i]=nums1[i];
       for(int i=0;i<nums2.length;i++)
       c[i+nums1.length]=nums2[i];
       Arrays.sort(c);
       int mid=c.length/2;
       if(c.length%2==1)
         return (double)c[mid];
        else 
        {
            return ((double)c[mid-1]+(double)c[mid])/2;
        }
    }
}

1482. 制作 m 束花所需的最少天数

提示

中等

305

相关企业

给你一个整数数组 bloomDay，以及两个整数 m 和 k 。

现需要制作 m 束花。制作花束时，需要使用花园中 相邻的 k 朵花 。

花园中有 n 朵花，第 i 朵花会在 bloomDay[i] 时盛开，恰好 可以用于 一束 花中。

请你返回从花园中摘 m 束花需要等待的最少的天数。如果不能摘到 m 束花则返回 -1 。

示例 1：

输入：bloomDay = [1,10,3,10,2], m = 3, k = 1
输出：3
解释：让我们一起观察这三天的花开过程，x 表示花开，而 _ 表示花还未开。
现在需要制作 3 束花，每束只需要 1 朵。
1 天后：[x, _, _, _, _]   // 只能制作 1 束花
2 天后：[x, _, _, _, x]   // 只能制作 2 束花
3 天后：[x, _, x, _, x]   // 可以制作 3 束花，答案为 3

示例 2：

输入：bloomDay = [1,10,3,10,2], m = 3, k = 2
输出：-1
解释：要制作 3 束花，每束需要 2 朵花，也就是一共需要 6 朵花。而花园中只有 5 朵花，无法满足制作要求，返回 -1 。

示例 3：

输入：bloomDay = [7,7,7,7,12,7,7], m = 2, k = 3
输出：12
解释：要制作 2 束花，每束需要 3 朵。
花园在 7 天后和 12 天后的情况如下：
7 天后：[x, x, x, x, _, x, x]
可以用前 3 朵盛开的花制作第一束花。但不能使用后 3 朵盛开的花，因为它们不相邻。
12 天后：[x, x, x, x, x, x, x]
显然，我们可以用不同的方式制作两束花。

示例 4：

输入：bloomDay = [1000000000,1000000000], m = 1, k = 1
输出：1000000000
解释：需要等 1000000000 天才能采到花来制作花束

示例 5：

输入：bloomDay = [1,10,2,9,3,8,4,7,5,6], m = 4, k = 2
输出：9

提示：

• bloomDay.length == n
• 1 <= n <= 10^5
• 1 <= bloomDay[i] <= 10^9
• 1 <= m <= 10^6
• 1 <= k <= n

class Solution {
    public int minDays(int[] bloomDay, int m, int k) {
        int high=Integer.MIN_VALUE,low=Integer.MAX_VALUE;
        int days;
        if(m>bloomDay.length/k)            
        return -1;
        for(int i=0;i<bloomDay.length;i++)
         {
            low=Math.min(low,bloomDay[i]);
             high=Math.max(high,bloomDay[i]);
         }
         while(low<high)
         {
             days=(high-low)/2+low;
             if(make(bloomDay,m,k,days))
               high=days;
            else low=days+1;
         }
         return low;
    }
    public boolean make(int[] bloomDay,int m,int k,int day)
    {
        int sum=0;
        int maf=0;
        for(int i=0;i<bloomDay.length&&sum<m;i++)
        {
            if(bloomDay[i]<=day)
             {
                 maf++;
             if(maf==k)
             {
                 sum++;
                 maf=0;
             }
             }
             else maf=0;
        }
        return sum>=m;
             
    }
}

3. 无重复字符的最长子串

中等

9.7K

相关企业

给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。

示例 1:

输入: s = "abcabcbb"
输出: 3 
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。

示例 2:

输入: s = "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。

示例 3:

输入: s = "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
     请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。

提示：

• 0 <= s.length <= 5 * 10^4
• s 由英文字母、数字、符号和空格组成

class Solution {
    public int lengthOfLongestSubstring(String s) {
           int len=s.length();
          
           if(len<=0)
             return 0;
            char ch[]=s.toCharArray();
             int flag=0,maxv=1,i,j;
            for(i=1;i<ch.length;i++){
             for(j=flag;j<i;j++)
              {

              if(ch[i]==ch[j])
              {
                flag=j+1;
                break;
              }
              }
              maxv=Math.max(maxv,i-flag+1); 
              }
         
        return maxv;
    }
}