常用類
包裝類
在類中查看屬性方法的快捷鍵：Ctrl+F12
java.lang包會默認匯入每個Java檔案，所以我們不需要匯入這個包，直接用包中的類就好了
-
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
-
在Java中，類只能直接繼承一個類，但可以間接繼承多個類
-
包裝類就是八大基本型別對應的類（前六個包裝類是直接繼承Number類，間接繼承object類，后兩個是直接繼承object類）
-
我們為什么要引入包裝類？
- 將基本型別包裝成為對應的包裝類，就是為了獲取某些屬性，方法
- 集合（存放資料的）只能存放參考資料型別
我們以integer類作講解，其他都一樣：（類的學習都是使用API幫助檔案）
-
integer底層就是一個int型別的資料
-
int型別資料的最大最小值，直接類名呼叫屬性就可以了，例如：
System.out.println(Integer.MAX_VALUE); System.out.println(Integer.MIN_VALUE); -
integer類中沒有無參構造器
有參（字串）構造只能是可以轉換為int型別的字串
-
自動裝箱
int型別轉換為integer，例如:
Integer i1=12; //其實內部進行的操作是，Integer i1=Integer.valueOf(12);這步我們要通過反編譯工具才可以看到 -
自動拆箱
integer型別轉換為int型別，例如：
int a=i1; -
compareTo方法，就是比較大小，例如：
System.out.println(i1.compareTo(i2));//這個方法的回傳值就是一個int型別 -
equals方法，比較是否相等，比較的是數值，例如：
System.out.println(i1.equals(i2)); //等于比較的是地址，就是看是否為同一個值 System.out.println(i1==i2); -
自動裝箱的重點：
Integer i1=12; Integer i2=12; System.out.println(i1==i2);//回傳值為true，因為值在-128到127之間就直接在一個陣列中取值，所以為true /* 如果不在這個范圍內就會創建一個物件，不在那個陣列里取值，而是自己創建物件存值，所以這也說明了 自動裝箱不一定會創建物件，還有數值超出那個范圍才會創建物件 */ -
intValue()方法，將integer轉換為int型別
System.out.println(i1.intValue()); -
parseInt()方法，將String型別轉換為int型別，字串要可以轉換為int，不然會報例外
int i = Integer.parseInt("12"); -
valueof(int i)/(String s)方法，就是將int型別轉換為integer型別/將String型別轉換為int型別
String類
從屬于java.lang包
-
String類的底層就是一個char型別的陣列
-
創建物件時呼叫構造器就是對底層char型別陣列的賦值
String類中有很多構造器，可以通過創建物件呼叫構造器，例如：
String s1 = new String(); String s2 = new String("abc"); String s3 = new String(new char[]{'1', '2', '3'});
一般都是用物件名去呼叫方法
String類中的方法：
str1.length()，就是str1的長度，底層就是char型別陣列的長度（回傳結果為int值）
str1.isEmpty()判斷這個物件是否為空（回傳結果為布林值）
str1.charAt(2)得到該陣列下標（2）對應元素的值（回傳結果就是元素對應的值）
str5.equals(str6)判斷兩個物件值是否相等(回傳值為布林值)，內部先判斷是否相等，在判斷長度是否相等，在判斷值是否相等
-
compareTo()方法
String s4="abc"; String s5="abcdef"; System.out.println(s4.compareTo(s5));//回傳4，4是長度差1 //這種情況下回傳的就是長度差，因為前三個字符是一樣的 String s4="abc"; String s5="defghj"; System.out.println(s4.compareTo(s5));//回傳的是ASCII碼 //只要前三個字符中有一個不一樣，就會回傳ASCII碼，只有前三個字串全部一樣才會回傳長度差 -
indexOf()方法
System.out.println(s5.indexOf('f'));//輸出的值為元素對應的下標，是個int值 -
API幫助檔案提供的是我們可以使用的方法，像private修飾的方法我們就不能使用，所以API檔案也不會提供給我們
-
substring()方法，字串的截取
String s5="abcdef"; String substring = s5.substring(2); System.out.println(substring);//輸出cdef String substring1 = s5.substring(2, 3);//這里只能輸出一個字符，因為在Java很多地方都是包頭不包尾的 System.out.println(substring1);//輸出c -
concat()方法，就是兩個字串進行拼接
String s4="abc"; String s5="abcdef"; System.out.println(s4.concat(s5));//輸出abcabcdef -
replace()方法，就是將字串中的一個字符替換為另一個字符
String s4="abc"; System.out.println(s4.replace('a', 'p'));//輸出結果為pbc,就是將a字符替換成為p字符 -
有回傳值的方法可以先回傳一個值，然后sout輸出，也可以直接sout輸出
-
toUpperCase()方法，將字串中全部字符轉換為大寫
String s5="abcdef"; System.out.println(s5.toUpperCase());//輸出結果為ABCDEF -
toLowerCase()方法，將字串中的全部字符轉換為小寫
String s5="AAAAAA"; System.out.println(s5.toLowerCase());//輸出結果為aaaaaa -
trim()方法，去掉首尾空格
String s5=" AAAA AA "; System.out.println(s5.trim());//輸出結果為AAAA AA -
toString()方法，誰呼叫就回傳誰
String s5="asdfghj"; System.out.println(s5.toString());//輸出結果為asdfghj -
valueOf()方法，將int型別的值轉換為字串
System.out.println(String.valueOf(12));
String記憶體+反編譯驗證
字串定義的方式：
String s1="abc";
String s2="a"+"b"+"c";
String s3="abc"+"";
//字串拼接，會進行編譯期優化，直接拼成最終你要的字串
String s4=s1+"";
//變數參與運算，就會在堆中開辟空間，會創建一個StringBuilder物件
String s5=new String("abc");
//創建物件，會在堆中開辟空間
System.out.println(s1==s2);//輸出true
System.out.println(s1==s3);//輸出true
System.out.println(s1==s4);//輸出false
System.out.println(s1==s5);//輸出false
編譯器優化：自動將s2，s3拼接為"abc"，將s4拼接為s1，直接拼成最終你要的字串
變數的記憶體地址是由第一個指向的位置決定的（我自己理解出的，不一定對）
-
s1到s5在記憶體中的存盤圖大致為：
-
壓堆疊（入堆疊）：物件名，變數名啥的都會被壓入堆疊中，具體怎么壓我現在也不知道
StringBuilder類
-
底層最重要的兩個數是char型別的陣列和int型別的數
-
StringBuilder的無參構造會呼叫父類的構造器并給char型別陣列確定長度為16
你要是呼叫有參構造器的話會將陣列長度確定為你傳的那個數字，例如：
StringBuilder stringBuilder = new StringBuilder(23);//開辟長度為23的陣列你要呼叫字串有參構造的話，開辟陣列長度為字串長度加默認長度16
StringBuilder stringBuilder1 = new StringBuilder("abc");//開辟長度為19的陣列StringBuilder底層的char陣列長度要是不夠用了，它會重新創建一個陣列，而String是不能重新創建陣列
-
String是不可變字串，StringBuilder是可變字串
StringBuilder的常用方法
StringBuilder與StringBuffer的區別聯系
利用陣列擴容原理（StringBuilder類的原理）創建一個類來模擬集合Arraylist：
注意細節：this就是呼叫本類的構造器，而super是呼叫父類的構造器
為什么我們要說一個類的底層是一個陣列或變數啥的？
因為我們可以發現所有的屬性和方法都是給那個陣列或變數進行操作，所以我們說這個類的底層就是一個陣列或變數啥的
實作代碼為：
package 包;
import java.lang.management.MemoryUsage;
public class MyCollection {
//底層是一個object陣列
Object[] value;
//計陣列中被占用的個數
int size;
//定義無參構造
public MyCollection(){
value=https://www.cnblogs.com/H-scholar/p/new Object[3];//陣列長度賦值為3
}
//定義有參構造，陣列長度由引數決定
public MyCollection(int num){
value=new Object[num];
}
//往陣列里放東西的方法
public MyCollection add(Object obj){
value[size]=obj;
size++;
//一旦超出范圍，我們就要進行陣列的擴容
if (size>value.length-1){
//擴容:創建一個新的陣列
Object[] newObj=new Object[value.length*2+2];
//將老陣列中的東西復制到新陣列中
for (int i = 0; i <= value.length-1; i++) {
newObj[i]=value[i];
}
//將value指向newObj，下次就是直接向新陣列中放值
value=newObj;
}
return this;
}
//取值
public Object get(int index){
if (index<0||index>=size){
throw new RuntimeException("超出邊界");
}
return value[index];
}
//計陣列長度
public int size(){
return size;
}
//重寫toString方法
public String toString() {
StringBuilder sb = new StringBuilder("[");
for (int i = 0; i < size; i++) {
sb.append(value[i]+",");
}
sb.setCharAt(sb.length()-1,']');
return sb.toString();
}
public static void main(String[] args) {
MyCollection mc1 = new MyCollection();//呼叫無參構造創建物件，定義陣列長度為3
MyCollection mc2 = new MyCollection(3);//呼叫有參構造，定義陣列長度為3
mc1.add(1);
mc1.add("aaa");
mc1.add(3);
mc1.add(4);//這個陣列是能放3個，這是第四個，陣列下標越界
mc1.add(5).add(6).add(7);
//輸出陣列元素
for (int i = 0; i <= mc1.size()-1; i++) {
System.out.println(mc1.get(i));
}
System.out.println(mc1);
System.out.println(mc1.toString());
}
}
時間處理類
-
date類
Date d = new Date(); //列印出當前系統的世間 System.out.println(d); -
date類中的其他表示時間的方法
Date d = new Date(); //列印出當前系統的時間 System.out.println(d); //以下是過期的列印時間的方法 System.out.println(d.toGMTString()); System.out.println(d.toLocaleString()); System.out.println(d.getYear());//當前年份減去1900 System.out.println(d.getMonth());//回傳的是0到11之間的數，5表示6月 System.out.println(d.getDate());//月份中的某一天，值在0到31之間 System.out.println(d.getDay());//回傳的是星期幾 //以下兩個列印的都是毫秒數，但是為什么第二個是常用的吶？ System.out.println(d.getTime());//回傳的是毫秒數 System.out.println(System.currentTimeMillis());//因為它不用創建物件，不用導包，直接呼叫 //java.sql.Date 年月日 //java.util.Date 年月日時分秒 java.sql.Date sqlDate=new java.sql.Date(12122121l); System.out.println(sqlDate); //將String型別轉換為java.sql.Date java.sql.Date date = sqlDate.valueOf("2019-10-10"); //java.util.Date轉換為java.sql.Date(util.Date呼叫自己的方法充當sql.Date的引數) java.sql.Date date1 = new java.sql.Date(new Date().getTime()); //java.sql.Date轉換為java.util.Date(類轉類，用的是繼承關系，父類子類的關系) Date date2=date1 -
java.sql包下還有兩個時間類，Time,Timestamp類，知道有這兩個類就行了
-
String轉換為java.util.Date
//String----->java.util.Date //1. String----->java.sql.Date java.sql.Date date3 = java.sql.Date.valueOf(2019-1-8); //2. java.sql.Date----->java.util.Date Date date4=date3;這種方法有局限：valueOf方法中字串格式必須為：年--月--日
實作開發作業中將String轉換為java.util.Date需要借助Dateformat類（日期格式化）
//創建實作類物件時需要確定日期的格式，字符可以是多個也可以是單個，例如：y-M-d h-m-s SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd hh-mm-ss"); try { //parse方法的作用：String----->Date //這里的日期格式必須和確定的日期格式相同 Date parse = simpleDateFormat.parse("2100-12-10 10-20-30"); System.out.println(parse); } catch (ParseException e) { e.printStackTrace(); } //format方法的作用：Date----->String //這里轉換為的String格式為創建物件時確定的日期格式 String format = simpleDateFormat.format(new Date()); System.out.println(format);
字符代表的意思：
-
類創建物件失敗的原因：
- 介面
- 抽象類
- 沒有無參構造，需要用有參構造創建物件
- 無參構造被private修飾
-
Calendar類（日歷）
很強大，但是我們用得少
注意：Calendar類本身（抽象類）不能創建物件，但我們可以讓類通過呼叫方法來創建物件，也可以創建它實作類的物件來創建物件，例如：
Calendar cal1 =Calendar.getInstance(); Calendar cal2 = new GregorianCalendar();Calendar類中的方法：
//獲取方法： System.out.println(cal1.get(Calendar.YEAR));//輸出2021 System.out.println(cal1.get(Calendar.MONTH));//輸出的月份是當前月份減1 System.out.println(cal1.get(Calendar.DATE));//輸出20號 System.out.println(cal1.get(Calendar.DAY_OF_WEEK));//輸出的是一個星期中的第幾天，例如：星期六是一個星期中 的第七天 System.out.println(cal1.getActualMaximum(Calendar.DATE));//輸出這個月中最大的一天 System.out.println(cal1.getActualMaximum(Calendar.MONTH));//輸出11，就是12月的意思，因為從0開始 System.out.println(cal1.getActualMinimum(Calendar.DATE));//一個月中最小的一天肯定是1 //設定方法： cal1.set(Calendar.DATE,16);//修改為16號 cal1.set(Calendar.MONTH,9);//修改為9月 cal1.set(Calendar.YEAR,2051);//修改為2051年 System.out.println(cal1);- String----->Calendar，先轉換為date，在轉換為Calendar
Calendar cal = Calendar.getInstance(); //String----->Calendar //String----->Date Date date = Date.valueOf("2019-2-10"); //Date----->Calendar cal.setTime(date); System.out.println(cal);列印輸出日歷表：
package 包; import java.sql.Date; import java.util.Calendar; import java.util.Scanner; public class Test { public static void main(String[] args) { System.out.print("請輸入你想要查看的日期：--(格式例如：2019-10-10):"); Scanner sc=new Scanner(System.in); String str = sc.next();//這個方法使用來接收鍵盤輸入的，接收到資料后要回傳一個值 //String----->Calendar 為什么要轉為Calendar型別？ 答：因為這個類比較強大，只有轉化為Calendar類才可以進行后續步驟 Date valueOf = Date.valueOf(str); Calendar cal = Calendar.getInstance(); cal.setTime(valueOf);//轉換成功 System.out.println("日\t一\t二\t三\t四\t五\t六"); int count=0; //求出這個月中的最大天數 int actualMaximum = cal.getActualMaximum(Calendar.DATE); //獲取當天的天數 int nowDay = cal.get(Calendar.DATE); //修改 cal.set(Calendar.DATE,1); //空格 int num = cal.get(Calendar.DAY_OF_WEEK); for (int i = 1; i <=num-1 ; i++) { System.out.print("\t"); } count+=(num-1); for (int i = 1; i <= actualMaximum; i++) { if (i!=nowDay){ System.out.print(i+"\t"); }else{ System.out.print(i+"*\t"); } count++; if (count%7==0){ System.out.println(); } } } }
列舉
-
用enum關鍵字來表示
-
列舉的定義
public enum Test { SPRING,SUMMER,AUTUMN,WINTER; } -
列舉的創建
public void test1(){ //列舉的創建 Test test=Test.SPRING; } -
列舉的常用方法
//values()方法，將列舉直接變成陣列，屬性就是元素，型別就是列舉名 public class TestEnum { @Test //加上這個注釋就可以直接執行，不需要main方法 public void test(){ Season[] values = Season.values(); for (Season value : values) { System.out.println(value); } } } //ordinal()方法 Season[] values = Season.values(); for (Season value : values) { System.out.println(value.ordinal()); } -
用列舉來做一個交通信號燈的實體
import org.junit.Test; public class TestEnum { TrafficLight light=TrafficLight.RED; public void test(){ switch (light){ case RED: this.light=TrafficLight.GREEN;break; case GREEN: this.light=TrafficLight.YELLOW;break; case YELLOW: this.light=TrafficLight.RED;break; } } @Test public void test1(){ for (int i = 0; i < 11; i++) { test(); System.out.println(light); } } } -
列舉的構造方法只能用private修飾
-
只有創建了構造器，列舉的屬性后才會有括號
@Test public void test5(){ //創建列舉 列舉屬性中的值會直接傳到構造器中,可以用構造器來給列舉的屬性賦值 Orientation north = Orientation.NORTH; System.out.println(north.getcity()); } -
EnumMap是一個類（要求所有的鍵都來自同一個列舉） 是Map的子類
@Test public void test9(){ //EnumMap EnumMap<Orientation,String> map=new EnumMap<>(Orientation.class);//括號中要寫鍵的class //第二個尖括號中的泛型可以不寫 map.put(Orientation.NORTH,"beijing"); map.put(Orientation.SOUTH,"nanjing"); map.put(Orientation.WEST,"xizang"); map.put(Orientation.EAST,"shanghai"); //先獲取他們所有的鍵 for (Orientation o:map.keySet()){ System.out.println(o+":"+map.get(o)); } }
Math，Random類
-
Math類從屬于java.lang包，無參構造被private修飾
Math類下的一些靜態的屬性與方法
package 包; import java.sql.Date; import java.util.Calendar; import java.util.Scanner; import static java.lang.Math.*;//靜態匯入：將Math類中的靜態的東西全部匯入 public class Test { public static void main(String[] args) { //圓周率 System.out.println(PI); //次冪 System.out.println(pow(3.0,2.0)); //開平方 System.out.println(Math.sqrt(9.0)); //向上取值 System.out.println(Math.ceil(9.1)); //向下取值 System.out.println(Math.floor(9.9)); //四舍五入 System.out.println(Math.round(5.1)); //亂數 范圍[0.0,1.0)之間 System.out.println(Math.random()); //絕對值 System.out.println(Math.abs(-9.2)); //取小 System.out.println(Math.min(2.0,9.8)); //取大 System.out.println(Math.max(2.0,9.6)); } //如果本類中有相同的方法，那么優先走本類中的，本類中沒有，就去靜態匯入類中找 public static double sqrt(double d){ return 8.8; } } -
Random類
//只要你給的數是一個值，它產生的亂數就永遠是那些，例如：你傳入了5，輸出的亂數就只會是那些 //你要想讓這些亂數變，就必須一直改變引數 Random r = new Random(5); for (int i = 1; i <= 10; i++) { System.out.println(r.nextInt()); } //可以通過這個方式來改變亂數 Random r = new Random(System.currentTimeMillis()); for (int i = 1; i <= 10; i++) { System.out.println(r.nextInt()); } //也可以通過這樣的方式來改變亂數 public static void main(String[] args) { //因為無參構造內部呼叫的是納秒，所以無參構造的亂數是一直變的 Random r = new Random(); for (int i = 1; i <= 10; i++) { //還可以是nextDouble/nextBoolean/nextInt System.out.println(r.nextBoolean()); /* 呼叫nextDouble方法默認亂數范圍是0.0到1.0之間，取0.0不取1.0 我們可以在nextInt方法內指定范圍，指定數字是多少，范圍就是0到多少 例如：指定引數為10，亂數的范圍就是0到10，取0不取10 */ } }要想讓亂數一直都是變的：1. 要么是一直改變有參構造的引數（通過呼叫毫秒等），2. 要么是直接通過無參構造創建物件
學習random類的原因是：Math呼叫亂數的底層是呼叫random類的nextDouble方法,所以Math.random的范圍是在0.0--1.0之間
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/263198.html
標籤：Java
上一篇：手把手教你Spring Boot整合Mybatis Plus 代碼生成器
下一篇：Java中zip的壓縮和解壓縮