day01
static 關鍵字
1、修飾屬性
Java靜態屬性和類相關, 和具體的實例無關. 換句話說, 同一個類的不同實例共用同一個靜態屬性
2、修飾方法
如果在任何方法上應用 static 關鍵字，此方法稱爲靜態方法。
靜態方法屬於類，而不屬於類的對象。
可以直接調用靜態方法，而無需創建類的實例。
靜態方法可以訪問靜態數據成員，並可以更改靜態數據成員的值
注意事項1: 靜態方法和實例無關, 而是和類相關. 因此這導致了兩個情況:
靜態方法不能直接使用非靜態數據成員或調用非靜態方法(非靜態數據成員和方法都是和實例相關的).
this和super兩個關鍵字不能在靜態上下文中使用(this 是當前實例的引用, super是當前實例父類實例的引用, 也
是和當前實例相關).
注意事項2
我們曾經寫的方法爲了簡單, 都統一加上了 static. 但實際上一個方法具體要不要帶 static, 都需要是情形而定.
main 方法爲 static 方法
3、代碼塊
4、修飾類
day02
1、方法沒有返回值一般都是說構造函數，void叫返回值爲空
2、給定一個排序數組和一個目標值，在數組中找到目標值，並返回其索引。如果目標值不存在於數組中，返回它將會被按順序插入的位置。
你可以假設數組中無重複元素。
示例 1:
輸入: [1,3,5,6], 5
輸出: 2
示例 2:
輸入: [1,3,5,6], 2
輸出: 1
示例 3:
輸入: [1,3,5,6], 7
輸出: 4
示例 4:
輸入: [1,3,5,6], 0
輸出: 0
來源：力扣（LeetCode）
鏈接：https://leetcode-cn.com/problems/search-insert-position
class Solution {
public int searchInsert(int[] nums, int target) {
//二分查找
int left = 0;
int right = nums.length - 1;
while(left <= right){
int mid = (left + right) / 2;
if(nums[mid] == target){
return mid;
}else if(nums[mid] > target){
right = mid - 1;
}else{
left = mid + 1;
}
}
return left;
// for(int i = 0; i < nums.length; i++){
// if(target <= nums[i]){
// return i;
// }
// }
// return nums.length;
}
}
day03
鏈接：https://www.nowcoder.com/questionTerminal/18bbe97d85584ea9a83042c6a4287d5c
來源：牛客網
下面的方法，當輸入爲2的時候返回值是多少？
public static int getValue(int i) {
int result = 0;
switch (i) {
case 1:
result = result + i;
case 2:
result = result + i * 2;
case 3:
result = result + i * 3;
}
return result;
}
case只是個入口，如果沒有break;會從入口處將後面所有的case全部執行一次。
383.贖金信：
來源：力扣（LeetCode）
鏈接：https://leetcode-cn.com/problems/ransom-note
給定一個贖金信 (ransom) 字符串和一個雜誌(magazine)字符串，判斷第一個字符串ransom能不能由第二個字符串magazines裏面的字符構成。如果可以構成，返回 true ；否則返回 false。
(題目說明：爲了不暴露贖金信字跡，要從雜誌上搜索各個需要的字母，組成單詞來表達意思。)
注意：
你可以假設兩個字符串均只含有小寫字母。
canConstruct(“a”, “b”) -> false
canConstruct(“aa”, “ab”) -> false
canConstruct(“aa”, “aab”) -> true
class Solution {
public boolean canConstruct(String ransomNote, String magazine) {
if(ransomNote.length() > magazine.length()) {
return false;
}
int[] caps = new int[26];
for(char c : ransomNote.toCharArray()) {
int index = magazine.indexOf(c, caps[c - 'a']);
if(index == -1){
return false;
}
caps[c - 'a'] = index + 1;
}
return true;
}
}
9.迴文數
來源：力扣（LeetCode）
鏈接：https://leetcode-cn.com/problems/palindrome-number
判斷一個整數是否是迴文數。迴文數是指正序（從左向右）和倒序（從右向左）讀都是一樣的整數。
示例 1:
輸入: 121
輸出: true
示例 2:
輸入: -121
輸出: false
解釋: 從左向右讀, 爲 -121 。 從右向左讀, 爲 121- 。因此它不是一個迴文數。
示例 3:
輸入: 10
輸出: false
解釋: 從右向左讀, 爲 01 。因此它不是一個迴文數。
進階:
你能不將整數轉爲字符串來解決這個問題嗎？
class Solution {
public boolean isPalindrome(int x) {
if(x < 0 || (x % 10 == 0 && x != 0)){
return false;
}
int num = 0;
while(x > num){
num = num * 10 + x % 10;
x /= 10;
}
return x == num || x == num / 10;
}
}
day04
鏈接：https://www.nowcoder.com/questionTerminal/870eeb30a78e4a03b15c6d45e5f16bf9
來源：牛客網
1.下面有關java final的基本規則，描述錯誤的是？
A.final修飾的類不能被繼承
B.final修飾的成員變量只允許賦值一次，且只能在類方法賦值
C.final修飾的局部變量即爲常量，只能賦值一次。
D.final修飾的方法不允許被子類覆蓋
答案爲：B
final修飾的成員變量爲基本數據類型是，在賦值之後無法改變。當final修飾的成員變量爲引用數據類型時，在賦值後其指向地址無法改變，但是對象內容還是可以改變的。
final修飾的成員變量在賦值時可以有三種方式。1、在聲明時直接賦值。2、在構造器中賦值。3、在初始代碼塊中進行賦值。
final修飾的方法，不允許被子類覆蓋。
final修飾的類，不能被繼承。
final修飾的變量，不能改變值。
final修飾的引用類型，不能再指向別的東西，但是可以改變其中的內容。
鏈接：https://www.nowcoder.com/questionTerminal/ee86c59bd1914239b148133793194f05?orderByHotValue=1&page=1&onlyReference=false
來源：牛客網
2.選項中哪一行代碼可以替換 //add code here 而不產生編譯錯誤
public abstract class MyClass {
public int constInt = 5;
//add code here
public void method() {}
}
A.public abstract void method(int a);
B.consInt=constInt+5;
C.public int method();
D.public abstract void anotherMethod(){}
解釋：
A方法的重載（正確）
C重載：方法名相同，參數列表不同，返回值不作要求
D抽象方法不能有方法體，即後面不能有括號
3.給定一個僅包含大小寫字母和空格 ’ ’ 的字符串 s，返回其最後一個單詞的長度。
如果字符串從左向右滾動顯示，那麼最後一個單詞就是最後出現的單詞。
如果不存在最後一個單詞，請返回 0 。
說明：一個單詞是指僅由字母組成、不包含任何空格的 最大子字符串。
示例:
輸入: “Hello World”
輸出: 5
來源：力扣（LeetCode）
鏈接：https://leetcode-cn.com/problems/length-of-last-word
class Solution {
public int lengthOfLastWord(String s) {
if(s == null || s.length() == 0 || " ".equals(s)){
return 0;
}
String[] newS = s.split(" ");
if(newS.length == 0){
return 0;
}
return newS[newS.length - 1].length();
}
}
4.給定兩個有序整數數組 nums1 和 nums2，將 nums2 合併到 nums1 中，使得 num1 成爲一個有序數組。
class Solution {
public void merge(int[] nums1, int m, int[] nums2, int n) {
System.arraycopy(nums2, 0, nums1, m, n);
Arrays.sort(nums1);
}
}
day05
1、下列java程序的輸出結果爲( )。
public class Example{
String str=new String("hello");
char[]ch={'a','b'};
public static void main(String args[]){
Example ex=new Example();
ex.change(ex.str,ex.ch);
System.out.print(ex.str+" and ");
System.out.print(ex.ch);
}
public void change(String str,char ch[]){
str="test ok";
ch[0]='c';
}
}
A: hello and ab
B: hello and cb
C: hello and a
D: test ok and ab
字符串是一種不可變對象. 它的內容不可改變.
String 類的內部實現也是基於 char[] 來實現的, 但是 String 類並沒有提供 set 方法之類的來修改內部的字符數組
2、 transient 變量和下面哪一項有關？ ( )
A: Cloneable
B: Serializable
C: Runnable
D: Comparable
我們都知道一個對象只要實現了Serilizable接口，這個對象就可以被序列化，java的這種序列化模式爲開發者提供了很多便利，我們可以不必關係具體序列化的過程，只要這個類實現了Serilizable接口，這個類的所有屬性和方法都會自動序列化。
這個類的有些屬性需要序列化，而其他屬性不需要被序列化；
java 的transient關鍵字爲我們提供了便利，你只需要實現Serilizable接口，將不需要序列化的屬性前添加關鍵字transient，序列化對象的時候，這個屬性就不會序列化到指定的目的地中。
- 在序列化的時候，被transient或者static修飾的屬性，不可以序列化。
- 一個類可以被序列化，那麼它的子類也可以被序列化。
- 序列化可以實現深複製，而Object中的clone實現的就只是淺複製。
3、已知有下列Test類的說明，在該類的main方法內，則下列哪個語句是正確的？（ ）
public class Test {
private float f = 1.0f;
int m = 12;
static int n = 1;
public static void main (String args[]) {
Test t = new Test();
}
}
A: t.f;
B: this.n;
C: Test.m
D: Test.f
選A
5. main方法是個static方法，然後static方法中不能直接訪問非static的屬性。
6. 靜態塊或者靜態方法中不能有this，super關鍵字
7. m不是靜態屬性，所以不能類名訪問。
1、類變量的調用：（1）靜態、非靜態方法中，可以直接調用。
2、成員變量的調用有2種方法：（1）非靜態方法中，可以通過this關鍵字直接調用。因爲成員變量的初始化時間先於類的構造函數執行前,自然保證了成員變量已經被賦值。（2）靜態方法中，先實例化類，利用實例化類的引用才能調用。
3、this關鍵字：（1）不能在靜態方法中使用。
217.存在重複元素
給定一個整數數組，判斷是否存在重複元素。
如果任何值在數組中出現至少兩次，函數返回 true。如果數組中每個元素都不相同，則返回 false。
class Solution {
public boolean containsDuplicate(int[] nums) {
if(nums.length == 0 || nums.length == 1){
return false;
}
for(int i = 0; i < nums.length; i++){
for(int j = i + 1; j < nums.length; j++){
if(nums[i] == nums[j]){
return true;
}
}
}
return false;
}
}
class Solution {
public boolean containsDuplicate(int[] nums) {
Arrays.sort(nums);
for(int i = 0; i < nums.length - 1; i++){
if(nums[i] == nums[i + 1]){
return true;
}
}
return false;
}
}
925.長按鍵入
你的朋友正在使用鍵盤輸入他的名字 name。偶爾，在鍵入字符 c 時，按鍵可能會被長按，而字符可能被輸入 1 次或多次。
你將會檢查鍵盤輸入的字符 typed。如果它對應的可能是你的朋友的名字（其中一些字符可能被長按），那麼就返回 True。
示例 1：
輸入：name = “alex”, typed = “aaleex”
輸出：true
解釋：‘alex’ 中的 ‘a’ 和 ‘e’ 被長按。
示例 2：
輸入：name = “saeed”, typed = “ssaaedd”
輸出：false
解釋：‘e’ 一定需要被鍵入兩次，但在 typed 的輸出中不是這樣。
示例 3：
輸入：name = “leelee”, typed = “lleeelee”
輸出：true
示例 4：
輸入：name = “laiden”, typed = “laiden”
輸出：true
解釋：長按名字中的字符並不是必要的。
來源：力扣（LeetCode）
鏈接：https://leetcode-cn.com/problems/long-pressed-name
class Solution {
public boolean isLongPressedName(String name, String typed) {
int n = name.length();
int t = typed.length();
if(t < n){
return false;
}
int i = 0;
int j = 0;
while(i < n && j < t){
//charAt()方法就是指定位置的字符輸出，類似於數組中的引用下標
//其範圍是0到"".length() - 1
if(name.charAt(i) == typed.charAt(j)){
i++;
j++;
}else if(j > 0 && typed.charAt(j) == typed.charAt(j - 1)){
j++;
}else{
return false;
}
}
return i == n;
}
}
day06
1.下面關於JAVA的垃圾回收機制，正確的是 B
A.程序可以任意指定釋放內存的時間
B.JAVA程序不能依賴於垃圾回收的時間或者順序
C.程序可明確地標識某個局部變量的引用不再被使用
D.程序可以顯式地立即釋放對象佔有的內存
java提供了一個系統級的線程，即垃圾回收器線程。用來對每一個分配出去的內存空間進行跟蹤。當JVM空閒時，自動回收每塊可能被回收的內存，GC是完全自動的，不能被強制執行。程序員最多隻能用System.gc()來建議執行垃圾回收器回收內存，但是具體的回收時間，是不可知的。
當對象的引用變量被賦值爲null，可能被當成垃圾。
C項錯誤的原因：局部變量存放在棧上，棧上的垃圾回收，由finalize()來實現
2.以下會產生信息丟失的類型轉換是( B）
A.float a=10
B.int a=（int）8846.0
C.byte a=10； int b=-a
D.double d=100
精度丟失只會發生在從大範圍到小範圍的轉換
byte 1字節
char 2字節
short 2字節
int 4字節
float 4字節
long 8字節
double 8字節
boolean 沒有(其實是佔八分之一個字節，也就是1個位)
3.多態，意味着一個對象有着多重特徵，可以在特定的情況下，表現不同的狀態，從而對應着不同的屬性和方法。 動態綁定，是指在執行期間判斷所引用對象的實際類型，根據其實際的類型調用其相應的方法。 作用消除類型之間的耦合關係。
4.給定一個字符串 S，返回 “反轉後的” 字符串，其中不是字母的字符都保留在原地，而所有字母的位置發生反轉。
示例 1：
輸入：“ab-cd”
輸出：“dc-ba”
示例 2：
輸入：“a-bC-dEf-ghIj”
輸出：“j-Ih-gfE-dCba”
示例 3：
輸入：“Test1ng-Leet=code-Q!”
輸出：“Qedo1ct-eeLg=ntse-T!”
來源：力扣（LeetCode）
鏈接：https://leetcode-cn.com/problems/reverse-only-letters
最笨的辦法，但最容易理解
class Solution {
public String reverseOnlyLetters(String S) {
char[] value = S.toCharArray();
int left = 0;
int right = S.length() - 1;
while(left < right){
if(((value[left] >= 65 && value[left] <= 90) ||
(value[left] >= 97 && value[left] <= 122)) &&
((value[right] >= 65 && value[right] <= 90) ||
(value[right] >= 97 && value[right] <= 122))){
char tmp = value[left];
value[left] = value[right];
value[right] = tmp;
left++;
right--;
}else if(value[left] < 65 || (value[left] > 90 && value[left] < 97) || value[left] > 122){
left++;
}else if(value[right] < 65 || (value[right] > 90 && value[right] < 97) || value[right] > 122){
right--;
}
}
return new String(value);
}
}
day07
1、在Java中，while()括號裏參數必須是boolean布爾類型,在C語言中，while()括號裏參數只要是大於0的int值都會被認爲是true.
2、在各自最優條件下,對N個數進行排序,哪個算法複雜度最低的是 A
A插入排序
B快速排序
C堆排序
D歸併排序
改正：冒泡排序的最好情況是O（N）
905、按奇偶排序數組
給定一個非負整數數組 A，返回一個數組，在該數組中， A 的所有偶數元素之後跟着所有奇數元素。
你可以返回滿足此條件的任何數組作爲答案。
class Solution {
public int[] sortArrayByParity(int[] A) {
int j = 0;
for(int i = 0; i < A.length; i++){
if(A[i] % 2 == 0){
//判斷A[i]是偶數，才發生交換，並且j++，否則j不變
int tmp = A[i];
A[i] = A[j];
A[j] = tmp;
j++;
}
}
return A;
}
public int[] sortArrayByParity(int[] A){
int left = 0;
int right = A.length - 1;
while(left < right){
while(left < right && A[left] % 2 == 0)
left++;
while(left < right && A[right] % 2 != 0)
right--;
int temp = A[left];
A[left] = A[right];
A[right] = temp;
}
return A;
}
}
- 尋找數組的中心索引
給定一個整數類型的數組 nums，請編寫一個能夠返回數組“中心索引”的方法。
我們是這樣定義數組中心索引的：數組中心索引的左側所有元素相加的和等於右側所有元素相加的和。
如果數組不存在中心索引，那麼我們應該返回 -1。如果數組有多箇中心索引，那麼我們應該返回最靠近左邊的那一個。
示例 1:
輸入:
nums = [1, 7, 3, 6, 5, 6]
輸出: 3
解釋:
索引3 (nums[3] = 6) 的左側數之和(1 + 7 + 3 = 11)，與右側數之和(5 + 6 = 11)相等。
同時, 3 也是第一個符合要求的中心索引。
示例 2:
輸入:
nums = [1, 2, 3]
輸出: -1
解釋:
數組中不存在滿足此條件的中心索引。
大神的思路，簡單易懂↓
class Solution {
public int pivotIndex(int[] nums) {
int sum = 0;
int sumleft = 0;
for(int i = 0; i < nums.length; i++){
sum += nums[i];
}
for(int i = 0; i < nums.length; i++){
if(sumleft * 2 + nums[i] == sum){
return i;
}
sumleft += nums[i];
}
return -1;
}
}
day08
66.加一
給定一個由整數組成的非空數組所表示的非負整數，在該數的基礎上加一。
最高位數字存放在數組的首位， 數組中每個元素只存儲單個數字。
你可以假設除了整數 0 之外，這個整數不會以零開頭。
示例 1:
輸入: [1,2,3]
輸出: [1,2,4]
解釋: 輸入數組表示數字 123。
示例 2:
輸入: [4,3,2,1]
輸出: [4,3,2,2]
解釋: 輸入數組表示數字 4321。
來源：力扣（LeetCode）
鏈接：https://leetcode-cn.com/problems/plus-one
別人的思路總是簡介明瞭，哭咧
class Solution {
public int[] plusOne(int[] digits) {
for(int i = digits.length - 1; i >= 0; i--){
if(digits[i] != 9){
digits[i] += 1;
return digits;
}
digits[i] = 0;
}
int[] newArr = new int[digits.length + 1];
newArr[0] = 1;
return newArr;
}
}
- 第三大的數
給定一個非空數組，返回此數組中第三大的數。如果不存在，則返回數組中最大的數。要求算法時間複雜度必須是O(n)。
示例 1:
輸入: [3, 2, 1]
輸出: 1
解釋: 第三大的數是 1.
示例 2:
輸入: [1, 2]
輸出: 2
解釋: 第三大的數不存在, 所以返回最大的數 2 .
示例 3:
輸入: [2, 2, 3, 1]
輸出: 1
解釋: 注意，要求返回第三大的數，是指第三大且唯一出現的數。
存在兩個值爲2的數，它們都排第二。
class Solution {
public int thirdMax(int[] nums) {
if(nums.length == 1) {
return nums[0];
}
if(nums.length == 2){
return Math.max(nums[0], nums[1]);
}
int max1 = Integer.MIN_VALUE;
int max2 = Integer.MIN_VALUE;
int max3 = Integer.MIN_VALUE;
boolean f = true;
int flag = 0;
for(int i = 0; i <nums.length; i++){
if(nums[i] == Integer.MIN_VALUE && f){
flag++;
f = false;
}
if(nums[i] > max1){
flag++;
max3 = max2;//原先第二大傳遞給第三大
max2 = max1;//原先最大值傳遞給第二大
max1 = nums[i];//更新最大值
}else if(nums[i] > max2 && nums[i] < max1){
flag++;
max3 = max2;
max2 = nums[i];
}else if(nums[i] > max3 && nums[i] < max2){
flag++;
max3 = nums[i];
}
}
return flag >= 3 ? max3 : max1;
}
}
掃盲：
Integer.MIN_VALUE，即-2147483648，二進制位如下：
1000 0000 0000 0000 0000 0000 0000 0000
在計算機的運算中，“-”（前綴）運算表示各二制位取反再加1，也就是說 b = -a 在計算機內部是 b = ~a + 1 這樣處理的，所以上面的位就變成了：
1000 0000 0000 0000 0000 0000 0000 0000 Integer.MIN_VALUE
取反 0111 1111 1111 1111 1111 1111 1111 1111 （取反之後變成了Integer.MAX_VALUE）
加１ 1000 0000 0000 0000 0000 0000 0000 0000 -Integer.MIN_VALUE（與原來的結果一樣）
在JDK中，整形類型是有範圍的，最大值爲Integer.MAX_VALUE，即2147483647，最小值爲Integer.MIN_VALUE -2147483648。
對整形最大值加1，2147483648（越界了），那麼此時值爲多少呢？結果是-2147483648，即是Integer.MIN_VALUE。
類似的，對Integer.MIN_VALUE取反或者取絕對值呢？仍爲Integer.MIN_VALUE，因爲值爲-2147483648，絕對值2147483648超過Integer.MAX_VALUE 2147483647。
所以就有以下結果
Integer.MAX_VALUE + 1 = Integer.MIN_VALUE
Math.abs(Integer.MIN_VALUE) = Integer.MIN_VALUE （絕對值）
Long，short，byte的結論是相同的。
day09
1、在java中，無論在何處調用，使用靜態屬性必須以類名做前綴。
A.正確
B.錯誤
1如果是本類使用，可以直接就用靜態變量名。2如果是其他類使用，可以使用類名來調用，也可以創建一個實例對象來調用。3如果靜態變量所在的類是靜態類，那麼不管在本類裏或者在其他外部類，都可以直接使用靜態變量名
2、哪個關鍵字可以對對象加互斥鎖？（）
A、synchronized
B、volatile
C、serialize
D、static
A、synchronized：修飾方法，代碼塊。互斥鎖（對象鎖），同步鎖定，即保證了可見性又保證了原子性。
B、volatile：修飾變量，保證了可見性，但是沒有保證原子性。同時禁止了指令重排序。
1. 可見性，是因爲JMM將工作內存置爲無效，每次線程讀取和寫入數據都是直接操作了主內存。（lock指令的作用）
2. 禁止了指令重排序：
1. 當程序執行到volatile變量的讀操作或者寫操作時，在其前面的操作的更改肯定全部已經進行，且結果已經對後面的操作可見；在其後面的操作肯定還沒有進行；
2. 在進行指令優化時，不能將在對volatile變量訪問的語句放在其後面執行，也不能把volatile變量後面的語句放到其前面執行。
C、serialize：代表序列化，一個類想要可以序列化，必須實現序列化接口（Serializable），序列化是爲了把對象變成流進行傳遞（內部、外部序列化）。
1. 序列化時，屬性可以序列化，方法不可以，序列ID必須寫成public static final形式的。
2. 序列化時，static和transient修飾的變量不可序列化。
3. 反序列化時，需要class文件。
D、static：修飾類，方法，成員變量（不可修飾局部變量，局部變量和形參只能使用final修飾）。被staic修飾的變量屬於類本身，而不是某一個類的某一個實例對象。同時靜態方法不可直接訪問非靜態成員，因爲類加載的順序問題。靜態塊、方法中不能出現this，super。
synchronized 關鍵字 : 用來給對象和方法或者代碼塊加鎖，當它鎖定一個方法或者一個代碼塊的時候，同一時刻最多隻有一個線程執行這個段代碼。
volatile：用來確保將變量的跟新操作通知到其他線程，當把變量聲明爲volatile類型後，編譯器與運行時都會注意到這個變量是共享的，因此不會將該變量上的操作與其他內存操作一起重排序。然而，在訪問volatile變量時不會執行加鎖操作，因此也就不會使執行線程阻塞，因此volatile變量是一種比 synchronized關鍵字更輕量級的同步機制。
serialize：Java 對象序列化爲二進制文件。
static關鍵字： static關鍵字可以修飾變量，方法，靜態代碼塊。
靜態變量:
由static修飾的變量稱爲靜態變量
靜態變量屬於類，而不屬於某個對象
靜態變量它的副本只有一個(靜態變量在類中只加載一)
靜態方法：
在靜態方法中只能調用靜態變量和靜態方法
在非靜態方法中，可以調用靜態方法或者變量。
在靜態方法中不能使用this和super關鍵字。
靜態代碼塊
作用:用來給靜態成員變量初始化
3、
- 兩數之和
給定一個整數數組 nums 和一個目標值 target，請你在該數組中找出和爲目標值的那 兩個 整數，並返回他們的數組下標。
你可以假設每種輸入只會對應一個答案。但是，你不能重複利用這個數組中同樣的元素。
示例:
給定 nums = [2, 7, 11, 15], target = 9
因爲 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
class Solution {
public int[] twoSum(int[] nums, int target) {
for(int i = 0; i < nums.length; i++){
for(int j = i + 1; j < nums.length; j++){
if(nums[j] == target - nums[i]){
return new int[] {i, j};
}
}
}
throw new IllegalArgumentException("No two sum solution");
}
}
day10
1、一個Java源程序文件中定義幾個類和接口，則編譯該文件後生成幾個以.class爲後綴的字節碼文件
2、要使某個類能被同一個包中的其他類訪問，但不能被這個包以外的類訪問，可以(A)
A讓該類不使用任何關鍵字
B使用private關鍵字
C使用protected關鍵字
D使用void關鍵字
default和protected的區別是：
前者只要是外部包，就不允許訪問。
後者只要是子類就允許訪問，即使子類位於外部包。
總結：default拒絕一切包外訪問；protected接受包外的子類訪問
3、判斷對錯。在java的多態調用中，new的是哪一個類就是調用的哪個類的方法。×
錯
多態有兩種情況：重載和覆寫
在覆寫中，運用的是動態單分配，是根據new的類型確定對象，從而確定調用的方法；
在重載中，運用的是靜態多分派，即根據靜態類型確定對象，因此不是根據new的類型確定調用的方法
8、字符串轉換整數 (atoi)
請你來實現一個 atoi 函數，使其能將字符串轉換成整數。
https://leetcode-cn.com/problems/string-to-integer-atoi/
class Solution {
public int myAtoi(String str) {
int ret = 0;
int flag = 1;
char[] charArr = str.toCharArray();
int length = str.length();
int i = 0;
int pop = 0;
for( ; i < length; i++) {
if(charArr[i] == ' ') {
continue;
}else{
if(charArr[i] == '-') {
i++;
flag = -1;
break;
}
if(charArr[i] == '+') {
i++;
break;
}
if(charArr[i] < '0' || charArr[i] >'9') {
return 0;
}else{
break;
}
}
}
if(i == length){
return 0;
}
for( ; i < length; i++) {
if(charArr[i] < '0' || charArr[i] > '9') {
return ret;
}
pop = (charArr[i] - 48) * flag;
if(ret > Integer.MAX_VALUE / 10 || (ret == Integer.MAX_VALUE / 10 && pop > 7)) {
return Integer.MAX_VALUE;
}
if(ret < Integer.MIN_VALUE / 10 || (ret == Integer.MIN_VALUE / 10 && pop < -8)) {
return Integer.MIN_VALUE;
}
ret = ret * 10 + pop;
}
return ret;
}
}
- 在排序數組中查找元素的第一個和最後一個位置
給定一個按照升序排列的整數數組 nums，和一個目標值 target。找出給定目標值在數組中的開始位置和結束位置。
你的算法時間複雜度必須是 O(log n) 級別。
如果數組中不存在目標值，返回 [-1, -1]。
示例 1:
輸入: nums = [5,7,7,8,8,10], target = 8
輸出: [3,4]
示例 2:
輸入: nums = [5,7,7,8,8,10], target = 6
輸出: [-1,-1]
學習了大佬寫的二分查找的邊界問題代碼，瞬間感覺開了竅,也對二分查找算法提升了更高的認識
class Solution {
public int[] searchRange(int[] nums, int target) {
return new int[] {left_bound(nums, target), right_bound(nums, target)};
}
private int left_bound(int[] nums, int target) {
if(nums.length == 0) {
return -1;
}
int left = 0;
int right = nums.length;
while(left < right) {
int mid = (left + right) / 2;
if(nums[mid] == target) {
right = mid;
}else if(nums[mid] < target) {
left = mid + 1;
}else if(nums[mid] > target) {
right = mid;
}
}
if(left == nums.length) {
return -1;
}
return nums[left] == target ? left : -1;
}
private int right_bound(int[] nums, int target) {
if(nums.length == 0) {
return -1;
}
int left = 0;
int right = nums.length;
while(left < right) {
int mid = (left + right) / 2;
if(nums[mid] == target) {
left = mid + 1;
}else if(nums[mid] < target) {
left = mid + 1;
}else if(nums[mid] > target) {
right = mid;
}
}
if(left == 0) {
return -1;
}
return nums[left - 1] == target ? (left - 1) : -1;
}
}
//學習了大佬寫的二分查找的邊界問題代碼，瞬間感覺開了竅,也對二分查找算法提升了更高的認識