本周主要学习了以下的内容
一：内部类：定义在其他类里面的类；
1.在测试时出现了一个问题：No enclosing instance of type is accessible（类型的封闭实例不可访问），通过百度知道，静态内部类不能直接访问外部类的非静态成员。但可以通过new外部类的方式来访问
2常用：匿名内部类
格式： new 类名或者接口名(){
重写方法;
}
本质上是一个继承了该类或者实现了该接口的子类匿名对象。(再次强调，是子类匿名对象，子类！)
二：object类：所用类的根类。
常见方法：1、public int hashCode()//返回该对象的哈希码值；
2、 getclass()返回调用此方法的类的对象
Class类的方法：
public String getName()：以 String 的形式返回此 Class 对象所表示的实体
3、 public String toString()返回该对象的字符串表示。
这个信息的组成就是这样，但是这个信息是没有任何意义的。所以，建议所有子类都重写该方法。
4、 equals:不重写相当于"=="
* 引用类型：默认情况下，比较的是地址值。
* 不过，我们可以根据情况自己重写该方法。一般重写都是自动生成，比较对象的成员变量值是否相同
5、clone：复制一个一样的对象，但地址值不同
三：Arrays常用功能
* 1、sort
* 2、toString//没有重写toString方法
* 3、binarySeacher();
四Scanner类：
1 public int nextInt():获取一个int类型的值
public String nextLine():获取一个String类型的值
2next（）和nextline（）的区别：next遇到有效字符后的空格符和制表符回车键都可以作为间隔符，nextline只有回车键可以作为间隔符，也就是next不包含空格，nextline包含空格。
五：正则表达式：是指一个用来描述或者匹配一系列符合某个句法规则的字符串的单个字符串。其实就是一种规则。有自己特殊的应用。
1、判断：String类的public boolean matches(String regex)
2、分割：String类的public String[] split(String regex)
3、替换：String类的public String replaceAll(String regex,String replacement)
六：BigInteger类---可以让超过Integer范围内的数据进行运算(即超过2147483647)
七： BigDecimal
由于在运算的时候，float类型和double很容易丢失精度，演示案例。所以，为了能精确的表示、计算浮点数，Java提供了BigDecimal
八：Date类
public long getTime():获取时间，以毫秒为单位
public void setTime(long time):设置时间
-1-.日期转字符串
Date d = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");//给定模式
String s = sdf.format(d);//format意为格式化
System.out.println(s);
2-字符串转日期
String str = "2021-07-14 12:12:12";
//在把一个字符串解析为日期的时候，请注意格式必须和给定的字符串格式匹配
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date dd = sdf2.parse(str);//parse意为解析
九：Calendar类(抽象类)以及getInstance()和get()方法
Calendar:它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。
public void add(int field,int amount):根据给定的日历字段和对应的时间，来对当前的日历进行操作。（amount可以是负的）
public final void set(int year,int month,int date):设置当前日历的年月日
十：集合：
Collection
|--List 有序,可重复
|--ArrayList
底层数据结构是数组，查询快，增删慢。
线程不安全，效率高
|--Vector
底层数据结构是数组，查询快，增删慢。
线程安全，效率低
|--LinkedList
底层数据结构是链表，查询慢，增删快。
线程不安全，效率高
|--Set 无序,唯一
|--HashSet
底层数据结构是哈希表。
如何保证元素唯一性的呢?
依赖两个方法：hashCode()和equals()
|--LinkedHashSet
底层数据结构是链表和哈希表
由链表保证元素有序
由哈希表保证元素唯一
|--TreeSet
底层数据结构是红黑树。
如何保证元素排序的呢?
自然排序
比较器排序
十一：map集合：成对出现，键唯一，值可重复；
TreeMap:是基于红黑树的Map接口的实现
LinkedHashMap:是Map接口的哈希表和链接列表实现，具有可预知的迭代顺序。
HashMap:是基于哈希表的Map接口实现
做题
* 编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。
不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。
示例 1：
输入：["h","e","l","l","o"]
输出：["o","l","l","e","h"]
*/
//错误做法
//class Solution2 {
// public void reverseString(char[] s) {
// String str=String.valueOf(s);
// StringBuilder sb=new StringBuilder(str);
// s=sb.reverse().toString().toCharArray();
// //这里实际上是创造了一个新的字符数组，并使其指向了本类中的变量s；
// //但是测试类中的s仍然指向原地址，且内容未改变
// }
//}
class Solution2 {
public void reverseString(char[] s) {
int left=0,right=s.length-1;
while(left<right) {
char temp=s[left];
s[left]=s[right];
s[right]=temp;
left++;
right--;
}
}
}
在一个 n * m 的二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个高效的函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
示例:
现有矩阵 matrix 如下：
[
[1, 4, 7, 11, 15],
[2, 5, 8, 12, 19],
[3, 6, 9, 16, 22],
[10, 13, 14, 17, 24],
[18, 21, 23, 26, 30]
给定 target = 5，返回 true。
给定 target = 20，返回 false。
*/
class Solution3 {
public boolean findNumberIn2DArray(int[][] matrix, int target) {
if(matrix.length==0){
return false;
}
int i=0,j=matrix[0].length-1;
while(i<matrix.length&&j>=0) {
if(matrix[i][j]<target) {
i++;
}else if(matrix[i][j]>target) {
j--;
}else {
return true;
}
}
return false;
}
}* 写一个函数，输入 n ，求斐波那契（Fibonacci）数列的第 n 项（即 F(N)）。斐波那契数列的定义如下：
F(0) = 0, F(1) = 1
F(N) = F(N - 1) + F(N - 2), 其中 N > 1.
斐波那契数列由 0 和 1 开始，之后的斐波那契数就是由之前的两数相加而得出。
答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。
示例 1：
输入：n = 2
输出：1
问题：大数越界： 随着 n 增大, f(n) 会超过 Int32 甚至 Int64 的取值范围，导致最终的返回值错误
*/
//方法一：数组储存
//class Solution3 {
// public int fib(int n) {
// int[]nums=new int [n+1];
// nums[0]=0;
// nums[1]=1;
// for(int i=2;i<n+1;i++) {
// nums[i]=(nums[i-1]%1000000007+nums[i-2]%1000000007)%1000000007;
//
// }
// return nums[n];
// }
//}
//方法二：
class Solution3 {
public int fib(int n) {
int a=0,b=1,sum=0;
for(int i=1;i<n;i++) {
sum=(a+b)%1000000007;
a=b;
b=sum;
}
return b;
}
}
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。
* 输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。
* 例如，数组 [3,4,5,1,2] 为 [1,2,3,4,5] 的一个旋转，该数组的最小值为1。
示例 1：
输入：[3,4,5,1,2]
输出：1
*/
//class Solution {
// public int minArray(int[] numbers) {
// for(int i=0;i<numbers.length-1;i++) {
// if(numbers[i+1]<numbers[i]) {
// return numbers[i+1];
// }
// }
// return numbers[0];
// }
//}
class Solution2 {
public int minArray(int[] numbers) {
int n=numbers.length;
int left=0,right=n-1;
while(left<=right) {
int mid=left+(right-left)/2;
if(numbers[mid]<numbers[right]) {
right=mid-1;
}
else if(numbers[mid]>numbers[right]) {
left=mid+1;
}
else {
right--;
}
}
return numbers[left];
}
}* 一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。
答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。
示例 1：
输入：n = 2
输出：2
思路：n=n-1+n-2;
*/
class Solution {
public int numWays(int n) {
int a=1,b=1,sum=1;
for(int i=2;i<=n;i++) {
sum=(a+b)%1000000007;
a=b;
b=sum;
}
return b;
}
}
892
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
