java窗口how2j_How2J Java 基础
Hello World
配置環境
假如 JDK 解壓縮后的包在 /home/cunyu/soft/jdk-11.0.7 目錄,則在 /etc/profile 文件中加入如下配置:
JAVA_HOME = /home/cunyu/soft/jdk-11.0.7
PATH = $JAVA_HOME/bin:$PATH
命令行運行程序
# 編譯
javac HelloWorld.java
# 運行
java HelloWorld
面向對象
類和對象
public class Item{
// 物品名
String name;
// 價格
int price;
public static void main(String[] args){
Item hp = new Item();
hp.name = "血瓶";
hp.price = 50;
Item shoes = new Item();
shoes.name = "草鞋";
shoes.price = 300;
Item sword = new Item();
sword.name = "長劍";
sword.price = 530;
}
}
方法
public class Item{
// 物品名
String name;
// 價格
int price;
// 血量
float hp;
public legendary(){
System.out.println("超神");
}
public float getHp(){
return hp;
}
public void recovery(float blood){
hp += blood;
}
}
變量
基本數據類型
總共有 8 大基本數據類型整性byte,1 個字節,8 位
short,2 個字節, 16 位
int,4 個字節,32 位
long,8 個字節,64 位
浮點型float,4 個字節,32 位
double,8 個字節,64 位字符型char,2 個字節,16 位
布爾型boolean,1 位
字面值
給基本數據類型變量賦值的方式叫做 字面值;
類型轉換
轉換規則
從小達到自動轉,從大到小強制轉;高精度向低精度轉換,可能導致溢出;
低精度可以向高精度轉換;
不同數據類型之間相互轉換需要進行 強制轉換;
命名規則及建議變量命名只能使用 字母、數字、_、$;
變量第一個字符只能 字母、$、_,不能是 數字;
變量命名不能使用關鍵字,但可以包含關鍵字;
盡量使用完整單詞,而非縮寫;
塊
Java 中 {} 包括的部分,稱為一個塊;
作用域字段、屬性、Field
當變量聲明在 類下 時,叫做 字段,或者 屬性、成員變量、Field,作用域 從聲明的位置開始的整個類;參數
當變量聲明在 方法上 時,叫做 參數,作用域為 該方法內所有代碼,其他方法和類都不能訪問;局部變量
當變量聲明在 方法內 時,叫做 局部變量,作用域為 從聲明的位置開始,直到所處于的塊結束;
final 修飾符
當聲明一個用 final 修飾的變量時,說明該變量 有且只有一次賦值的機會;
操作符
算數操作符+、-、×、/、%、++、--
當不同的運算單元(任一長度超過 int)進行運算時,最終返回結果按照最長的長度計算;
當不同的運算單元(任一長度不超過 int)進行運算時,最終返回結果按照 int 計算;
++、-- 前置時,先運算,再取值;后置時、先取值,再計算;
關系操作符>、>=、
邏輯操作符&、&&、|、||、!、^
長路與短路的區別:長路會運算符兩邊的值均進行運算,短路當運算符左側為 false 時,運算符右側則不再計算;
位運算符Integer.toBinaryString()、|、&、^、~、<>、>>>
>> 與 >>> 的區別>> 會將正數所有位右移,并在最前面補 0,會將負數所有位右移,并在最前面補 1;
>>> 會將負數的二進制的第一位的 1 也向右移動,然后在前面補 0,從而導致負數在無符號右移后,得到一個正數;
>> 移動后數的正負性不變,>>> 移動后變為正數;
三元操作符表達式?值1:值2,當表達式為真時,返回值 1;當表達式為假時,返回值 2;
控制流程
switchswitch 中可以使用 byte、short、int、char、String、enum;
每個表達式結束都應該有一個 break;
使用 String 的實質還是使用正數,是通過編譯后將其轉化為 hash 值;
數組
創建數組數組是一個 長度固定,包含 相同類型 數據的 容器;
若一個變量代表一個數組,則將這個變量叫做 引用;
// 聲明一個引用
int[] arr;
// 創建一個長度為 10 的數組,且使用引用 arr 指向該數組
初始化數組分配空間與賦值同步
//分配長度為 5 的數組,但未賦值
int[] a = new int[5];
//沒有賦值,那么就會使用默認值,作為int類型的數組,默認值是0
System.out.println(a[0]);
//進行賦值
a[0] = 100;
a[1] = 101;
a[2] = 103;
a[3] = 120;
a[4] = 140;分配空間同時賦值
// 方式 1,分配空間同時賦值
int[] arr1 = new int[]{100,102,444,836,3236};
// 方式 2
int[] arr2 = {100,102,444,836,3236};
// 方式 3,分配空間的同時指定內容
int[] arr3 = neew int[5]{100,102,444,836,3236};
數組排序
選擇排序思路
首先在未排序數組中找到最小元素,存放到排序數組的其實位置,然后再從剩余未排序的元素中尋找最小的元素,放到排序數組起始位置,以此類推直到數組所有元素排序完畢;實現
/**
* 選擇排序
* @param source 未排序數組
*/
public void selectSort(int[] source){
// 數組長度
int size = source.lenth;
for(int i = 0; i < size; i++){
for(int j = i + 1; j < size; j++){
// 進行交換,從小到大
if(source[i] > source[j]){
// 進行交換,從大到小
// if(source[i] < source[j])
int tmp = source[i];
source[i] = source[j];
source[j] = tmp;
}
}
}
}
冒泡排序思路
通過雙層循環,內層循環將相鄰的兩個數進行比較,將最大的一個數以冒泡(兩兩交換)的形式傳送到數組尾部,每次將一個最大值傳到數組尾部,外層循環則實現依次將當前最大值傳送,最終實現排序;實現
/**
* 冒泡排序
* @param source 未排序數組
*/
public void bubbleSort(int[] source){
// 數組長度
int size = source.length;
for(int i = 0; i < size - 1; i++){
for(int j = 0; j < size - 1 - i; j++){
if(source[j] > source[j + 1]){
int tmp = source[j];
source[j] = source[j + 1];
source[j + 1] = tmp;
}
}
}
}
數組復制
數組一旦分配空間,就不再可變,當我們需要在原有數組的基礎上增刪改查時,則需要對數組進行復制;將一個數組的值復制到另一個數組
/**
* @param src 源數組
* @param srcPos 源數組要復制的起始位置
* @param dest 目的數組
* @param destPos 目的數組要放置的起始位置
* @param length 復制的長度
*/
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)合并數組
import java.util.Arrays;
/**
* Created with IntelliJ IDEA.
* Version : 1.0
* Author : cunyu
* Email : cunyu1024@foxmail.com
* Website : https://cunyu1943.github.io
* 公眾號 : 村雨遙
* Date : 2020/5/6 上午10:58
* Project : mavenDemo
* Package : PACKAGE_NAME
* Class : MergeArr
* Desc : 合并數組
*/
public class MergeArr {
public static void main(String[] args) throws Exception {
int[] arr1 = {1, 5, 7, 9};
int[] arr2 = {0, 4, 11, 45};
int destSize = arr1.length + arr2.length;
int[] mergeArr = new int[destSize];
merge(arr1, arr2, mergeArr);
System.out.println(Arrays.toString(mergeArr));
}
/**
* 合并數組
*
* @param arr1 源數組 1
* @param arr2 源數組 2
* @param destArr 合并后的數組
*/
public static void merge(int[] arr1, int[] arr2, int[] destArr) {
// 將數組 1 合并到最終數組
System.arraycopy(arr1, 0, destArr, 0, arr1.length);
// 將數組 2 合并到最終數組
System.arraycopy(arr2, 0, destArr, arr1.length, arr2.length);
}
}
Arrays
方法功能copyOfRange數組復制toString()轉換為字符串sort排序binarySearch搜索equals判斷是否相同fill填充
import java.util.Arrays;
/**
* Created with IntelliJ IDEA.
* Version : 1.0
* Author : cunyu
* Email : cunyu1024@foxmail.com
* Website : https://cunyu1943.github.io
* 公眾號 : 村雨遙
* Date : 2020/5/6 下午1:27
* Project : mavenDemo
* Package : PACKAGE_NAME
* Class : ArraysOperation
* Desc : Arrays 常見操作
*/
public class ArraysOperation {
public static void main(String[] args) throws Exception {
int[] arr = {1, 9, 8, 49};
// 復制
int[] newArr = Arrays.copyOfRange(arr, 0, arr.length);
// 轉換為字符串
System.out.println(Arrays.toString(newArr));
// 排序
Arrays.sort(newArr);
// 搜索
System.out.println(Arrays.binarySearch(newArr, 8));
// 比較是否相等
System.out.println(Arrays.equals(arr, newArr));
// 填充
Arrays.fill(arr, 10);
System.out.println(Arrays.toString(arr));
}
}
類和對象
繼承
class Item{
String name;
int price;
}
public class Armor extends Item{
int ac;
public static void main(String[] args) {
Armor a1 = new Armor();
Armor a2 = new Armor();
// 布甲相關屬性
a1.name = "布甲";
a1.price = 300;
a1.hjdj =15;
// 鎖子甲相關屬性
a2.name = "鎖子甲";
a2.price = 500;
a2.hjdj =40;
}
方法重載
**方法重載 ** 指方法名一樣,但參數類型不一樣;
構造方法
通過一個類構建一個對象的過程叫做 實例化,而實例化是通過 構造方法 來實現的;構造方法名和類名一樣,但是 沒有返回類型,默認會提夠一個無參的構造方法,this 代表當前對象;
public class Hero{
String name;
float hp;
float armor;
int moveSpeed;
Hero(String name, float hp, float armor, int moveSpeed){
this.name = name;
this.hp = hp;
this.armor = armor;
this.moveSpeed = moveSpeed;
}
}
訪問修飾符常用修飾符
符號說明private私有package/friendly/default默認,protected受保護public公有修飾符作用域
自身同包子類不同包子類同包類其他類private訪問不能繼承不能繼承無法訪問無法訪問package/friendly/default訪問繼承不能繼承訪問無法訪問protected訪問繼承繼承訪問無法訪問public訪問繼承繼承訪問訪問修飾符使用場景屬性通常用 private 封裝;
方法一般用 public 方便調用;
會被繼承的方法,通常用 protected ;
package 使用較少;
原則:作用范圍盡量小;
類屬性定義:當類中一個屬性被 static 修飾時,叫做 類屬性,也叫 靜態屬性,當一個屬性被聲明為類屬性時,所有對象均共享一個值;
對象屬性 :又叫 實例屬性,非靜態屬性;
對象屬性與類屬性的對比 :不同對象的 對象屬性的值 都可能不一樣,但所有對象的 類屬性的值 都是一樣的;
若一個屬性對所有對象都不一樣,則該屬性應該設計為 對象屬性,因為它 跟著對象走;
若一個對象被所有對象共享,均一樣,則該屬性應該被設計為 類屬性;
訪問方式對象.類屬性 :teemo.hp ;
類.類屬性 :Hero.hp ,推薦使用;
類方法類方法 :又叫做 靜態方法,被 static 修飾的方法,訪問類方法,無需對象 存在就可以直接訪問,若某一方法中 未調用任何對象屬性,則可以設計為類方法;
對象方法 :又叫 實例方法,非靜態方法,訪問一個對象方法,必須建立在 有一個對象 的前提上,若某一方法中 訪問了對象屬性,則該方法 必須 設計為對象方法;
類方法調用方式:對象.類方法 :teemo.die() ;
類.類方法 :Hero.battleWin() ,推薦使用;
屬性初始化對象屬性初始化方式 :聲明該屬性時初始化;
構造方法中初始化;
初始化塊;
public class Hero{
// 聲明同時初始化
public String name = "teemo";
protected float hp;
float maxHP;
// 初始化塊初始化
{
maxHP = 999;
}
// 構造方法中初始化
public Hero(){
hp = 100;
}
}類屬性初始化方式 :聲明該屬性時初始化;
靜態初始化塊;
public class Hero{
public String name;
protected float hp;
float maxHP;
// 聲明時初始化
public static int itemCapacity = 10;
// 靜態初始化塊
static{
itemCapacity = 20;
}
}屬性初始化塊的執行順序:
靜態初始化塊 -> 非靜態初始化塊 ->構造方法 ;
單例模式定義 : 又叫 Singleton 模式,指在一個類在 JVM 中,只存在一個實例;
單例模式分類:餓漢式 : 無論如何都會創建一個實例,通過 public static 的 getInstance 方法獲取一個對象,每次獲取的都是同一個對象,屬于 立即加載,無論是否用到該對象,均加載;
懶漢式 :只有在調用 getInstance 方法時才會創建實例,每次獲取的都是同一個對象,屬于 延遲加載,只有在使用該對象時才加載,同時具有 線程安全;
單例模式三要素 :構造方法私有化 ;
靜態屬性指向實例 ;
public staic 的 getInstance 方法,**返回上一個要素中的靜態屬性 ** ;
/**
* 餓漢式
*/
public class Earth{
// 私有構造方法,使得無法在外部通過 new 實例化
private Earth(){
}
// 定義類屬性同時初始化
private static Earth instance = new Earth();
// private static 方法,用于獲取對象
public static Earth getInstance(){
return instance;
}
public static void main(String[] args){
Earth earth1 = Earth.getInstance();
Earth earth2 = Earth.getInstance();
// true
System.out.println(earth1 == earth2)
}
}
/**
* 懶漢式
*/
public class Earth{
// 私有構造方法,使得無法在外部通過 new 實例化
private Earth(){
}
// 定義類屬性
private static Earth instance;
// private static 方法,用于獲取對象
public static Earth getInstance(){
// instance 未指向任何對象,將其實例化
if(instance == null){
instance = new Earth();
}
return instance;
}
public static void main(String[] args){
Earth earth1 = Earth.getInstance();
Earth earth2 = Earth.getInstance();
// true
System.out.println(earth1 == earth2)
}
}
枚舉類型枚舉是一種特殊的類,方便定義常量,一般都是全大寫;
public enum Heros{
TANK,
WIZARD,
ASSASSIN,
WARRIOR,
ASSIST,
RANGED,
PUSH,
FARMING
}
public class Demo{
public static void main(String[] args){
for(Heros hero : Heros.values()){
System.out.println(hero);
}
}
}
接口與繼承
接口接口 無法用于實例化;
接口 無構造方法;
接口中的 方法均為抽象方法;
無法包含成員變量,除了 static 和 final 變量;
接口支持多繼承;
對象轉型
向上轉型(子類轉父類、實現類轉接口)
Hero hero = new Hero();
AdHero ad = new AdHero();
hero = ad;
向下轉型(父類轉子類、接口轉實現類)
Hero hero = new Hero();
AdHero ad = new AdHero();
ad = (AdHero)hero;
重寫
子類可以繼承父類對象方法,繼承后重復提供該方法,則叫做 方法的重寫,也叫覆寫(override);
class Item{
String name;
int price;
public void buy(){
System.out.println("購買");
}
public void effect(){
System.out.println("物品使用后生效");
}
}
public class LifePotion extends Item{
@override
public void effect(){
System.out.println("血瓶使用后回血");
}
}
多態操作符的多態 :同一操作符在不同情景下具有不同作用,如 + 兩側是整形,則代表 數字相加;若其中任意一個是字符串,則代表 字符串連接;
類的多態需要具備的條件 :父類(接口)引用指向子類對象 ;
調用的方法經歷重寫;
public interface Mortal{
public void die();
}
public class Hero{
public String name;
protected float hp;
public Hero(String name, float hp){
this.name = name;
}
public void kill(Mortal m){
m.die();
}
public static void main(String[] args){
Hero hero = new Hero("趙云", 1000.0f);
APHero ap = new APHero("安琪拉", 400.0f);
ADHero ad = new ADHero("后羿", 450.0f);
ADAPHero adap = new ADAPHero("嫦娥", 600.0f);
hero.kill(ad);
hero.kill(ap);
hero.kill(adap);
}
}
public class ADHero extends Hero implements Mortal{
@override
public void die(){
System.out.println("AD 被擊殺");
}
}
public class APHero extends Hero implements Mortal{
@override
public void die(){
System.out.println("AP 被擊殺");
}
}
public class ADAPHero extends Hero implements Mortal{
@override
public void die(){
System.out.println("ADAP 被擊殺");
}
}
隱藏定義 :父類和子類擁有相同名字的屬性或方法時,父類的同名屬性或方法形式上不見了,但實際仍存在;即對于被隱藏的屬性和方法,不會被覆蓋,當父類引用指向子類對象時,調用的隱藏屬性或方法仍然是父類的,而不會發生動態綁定;
public class Test {
public static void main(String[] args) {
Circle circle = new Circle();//本類引用指向本類對象
Shape shape = new Circle();//父類引用指向子類對象(會有隱藏和覆蓋)
System.out.println(circle.name);
circle.printType();
circle.printName();
//以上都是調用Circle類的方法和引用
System.out.println(shape.name);//調用父類被隱藏的name屬性
shape.printType();//調用子類printType的方法
shape.printName();//調用父類隱藏的printName方法
}
}
class Shape {
public String name = "shape";
public Shape(){
System.out.println("shape constructor");
}
public void printType() {
System.out.println("this is shape");
}
public static void printName() {
System.out.println("shape");
}
}
class Circle extends Shape {
public String name = "circle"; //父類屬性被隱藏
public Circle() {
System.out.println("circle constructor");
}
//對父類實例方法的覆蓋
public void printType() {
System.out.println("this is circle");
}
//對父類靜態方法的隱藏
public static void printName() {
System.out.println("circle");
}
}輸入結果如下 :
shape constructor
circle constructor
circle
this is circle
circle
shape
this is circle
shape
Object 類
toString()
所有類均繼承自 Object ,所以所有類均有 toString() 方法,返回 當前對象的字符串表達 ;
finalize()
當一個對象沒有任何引用指向的時候,就滿足垃圾回收的條件,當被垃圾回收時,其 finalize() 方法就會 被虛擬機 JVM 調用,此時無需開發人員主動調用;
equals()
用于判斷兩個對象內容是否相同;
==
不屬于 Object 類的方法,用于判斷兩個對象是否相同(即判斷兩個引用是否指向同一對象);
hashCode()
用于返回一個對象的哈希值;
getClass()
返回一個對象的 類對象,主要用于 反射機制;
final修飾類 :final 修飾類時,表示當前類不允許繼承;
修飾方法 :final 修飾方法時,表示該方法不允許被重寫;
修飾基本類型變量 :final 修飾基本類型變量時,表示該變量只有一次賦值機會;
修飾引用 :final 修飾引用時,表示該引用只有一次指向對象的機會;
抽象類定義:在類中聲明一個方法,該方法無具體實現,是一個 “空” 方法,則該方法叫做抽象方法,用 abstract 修飾;而當一個類有抽象方法時,該類必須被聲明為 抽象類,抽象類不能直接實例化;
接口與抽象類的區別 :子類 可以實現多個接口,但只能繼承一個抽象類;
抽象類可以定義 public、package、protected、private、靜態和非靜態屬性、final 和非 final 屬性,但 接口中聲明的屬性只能是 public、靜態、final;
內部類可以分為如下 4 類:非靜態內部類 :直接定義在一個類中,可以直接訪問外部類的 private 屬性,內部類實例化語法:內部類 對象名 = new 外部類().new 內部類();;
靜態內部類 :在一個類中聲明一個靜態內部類,不能訪問外部類的實例屬性和方法,只能訪問外部類私有靜態成員,不需要一個外部類的實例為基礎,可以直接實例化,語法如下: 外部類.靜態內部類 對象名 = new 外部類.靜態內部類();
package charactor;
public class Hero {
public String name;
protected float hp;
private static void battleWin(){
System.out.println("battle win");
}
//敵方的水晶
static class EnemyCrystal{
int hp=5000;
//如果水晶的血量為0,則宣布勝利
public void checkIfVictory(){
if(hp==0){
Hero.battleWin();
//靜態內部類不能直接訪問外部類的對象屬性
System.out.println(name + " win this game");
}
}
}
public static void main(String[] args) {
//實例化靜態內部類
Hero.EnemyCrystal crystal = new Hero.EnemyCrystal();
crystal.checkIfVictory();
}
}匿名類 :在 聲明一個類的同時實例化,使用外部局部變量時,該變量必修修飾為 final;
package charactor;
public abstract class Hero {
String name; //姓名
float hp; //血量
float armor; //護甲
int moveSpeed; //移動速度
public abstract void attack();
public static void main(String[] args) {
ADHero adh=new ADHero();
//通過打印adh,可以看到adh這個對象屬于ADHero類
adh.attack();
System.out.println(adh);
Hero h = new Hero(){
//當場實現attack方法
public void attack() {
System.out.println("新的進攻手段");
}
};
h.attack();
//通過打印h,可以看到h這個對象屬于Hero$1這么一個系統自動分配的類名
System.out.println(h);
}
}本地類 :可以看作是 帶名字的匿名類,匿名類不同之處在于內部類的是內部類必須聲明在成員的位置,即與屬性和方法平等位置,而本地類和匿名類一樣,直接聲明在代碼塊,可以是任何地方;
package charactor;
public abstract class Hero {
String name; //姓名
float hp; //血量
float armor; //護甲
int moveSpeed; //移動速度
public abstract void attack();
public static void main(String[] args) {
//與匿名類的區別在于,本地類有了自定義的類名
class SomeHero extends Hero{
public void attack() {
System.out.println( name+ " 新的進攻手段");
}
}
SomeHero h =new SomeHero();
h.name ="地卜師";
h.attack();
}
}練習
public abstract class Item{
public abstract void disposable();
public static void main(String[] args) throws Exception{
Item item = new Item(){
public void disposable(){
System.out.println("一次性");
}
}
}
}
默認方法
默認方法自 JDK8 加入,指 接口中也可以加入具體方法(即默認方法,聲明為 default),而不僅限于抽象方法;
最后練習
public abstract class Animal{
protected int legs;
protected Animal(int legs){
this.legs = legs;
}
public abstract void eat();
public void walk(int legs){
if(legs > 0){
System.out.println("用" + legs + "條腿走路")
}
}
}
class Spider extends Animal{
protected Spider(int legs){
super(legs);
}
@Override
public void eat(){
System.out.println("蜘蛛吃東西");
}
}
public interface Pet{
String name;
public void setName(String name);
public String getName();
public void play();
}
class Cat extends Animal implements Pet{
String name;
protected Cat(String name){
super(4);
this.name = name;
}
public Cat(){
this.name = "";
}
@Override
public void eat(){
System.out.println("貓在吃魚");
}
@Override
public void setName(String name){
this.name = name;
}
@Override
public String getName(){
return this.name;
}
@Overrid
public void play(){
System.out.println("貓在玩毛線");
}
}
class Fish extends Animal implements Pet{
private String name;
protected Fish(){
super(0);
}
@Override
public void setName(String name){
this.name = name;
}
@Override
public String getName(){
return this.name;
}
@Override
public void walk(int legs){
System.out.println("魚沒有腿,只能游泳");
}
@Override
public void play(){
System.out.println("魚在水力追蝌蚪");
}
@Override
public void eat(){
System.out.println("魚吃草");
}
}
數字與字符串
拆箱裝箱基本數據類型及對應封裝類
基本數據類型封裝類byteByteshortShortintIntegerlongLongfloatFloatdoubleDoublecharCharacterbooleanBoolean
graph TD
A[Number] --- B[Byte]
A[Number] --- C[Short]
A[Number] --- D[Integer]
A[Number] --- E[Long]
A[Number] --- F[Float]
A[Number] --- G[Double]自動裝箱:無需調用構造方法,通過 = 自動把 基本類型轉換為封裝類 的過程叫做自動裝箱;
自動拆箱 :無需調用對應方法,通過 = 自動將 封裝類轉換為基本類型 的過程叫做自動拆箱;
int 類型的最大最小值 : 最大值 :Integer.MAX_VALUE;最小值 :Integer.MIN_VALUE;
public class TestNumber{
public static void main(String[] args) throws Exception{
byte byteNum1 = 3;
// 自動裝箱
Byte byteNumClass1 = byteNum1;
// 自動拆箱
Byte byteNumClass2 = new Byte(byteNum1);
byte byteNum2 = byteNumClass2;
}
}
字符串轉換
數字轉字符串使用 String 類的靜態方法 valueOf;
現將基本類型封裝成對象,然后調用 toString 方法;
通過 + 將數字與 “” 相連;
public class Demo{
public void main(String[] args) throws Exception{
int num = 200;
// 方法 1
String numString1 = String.valueOf(num);
// 方法 2
Integer numClass = new Integer(num);
String numString2 = numClass.toString();
// 方法 3
String numString3 = num + "";
}
}
字符串轉數字通過各個封裝類的靜態方法 parseXxx 進行裝換;
public class Demo{
public void main(String[] args) throws Exception{
String numString1 = "34";
int num1 = Integer.parseInt(numString1);
String numString2 = "35.34";
float num2 = Float.parseFloat(numString2);
}
}
格式化輸出
字符含義%s字符串%d數字%n換行(平臺無關)
public class TestNumber {
public static void main(String[] args) {
String name ="迦羅";
int kill = 8;
String title="超神";
String sentenceFormat ="%s 在進行了連續 %d 次擊殺后,獲得了 %s 的稱號%n";
// printf 和 format 效果一樣
//使用printf格式化輸出
System.out.printf(sentenceFormat,name,kill,title);
//使用format格式化輸出
System.out.format(sentenceFormat,name,kill,title);
}
}換行符DOS 和 Windows 中,每行結尾是 \r\n;
Linux 中,每行結尾是 \n;
Mac 中,每行結尾是 \r;
常用格式化方式
import java.util.Locale;
public class TestNumber {
public static void main(String[] args) throws Exception{
int year = 2020;
//總長度,左對齊,補0,千位分隔符,小數點位數,本地化表達
//直接打印數字
System.out.format("%d%n",year);
//總長度是8,默認右對齊
System.out.format("%8d%n",year);
//總長度是8,左對齊
System.out.format("%-8d%n",year);
//總長度是8,不夠補0
System.out.format("%08d%n",year);
//千位分隔符
System.out.format("%,8d%n",year*10000);
//小數點位數
System.out.format("%.2f%n",Math.PI);
//不同國家的千位分隔符
// 法國
System.out.format(Locale.FRANCE,"%,.2f%n",Math.PI*10000);
// 美國
System.out.format(Locale.US,"%,.2f%n",Math.PI*10000);
// 英國
System.out.format(Locale.UK,"%,.2f%n",Math.PI*10000);
}
}
字符串創建字符串的方式當有一個 字面值 出現時,虛擬機自動創建一個字符串;
調用 String 的構造方法創建;
通過字符數組創建;
通過 + 進行字符串拼接;
public class TestString {
public static void main(String[] args) {
// 字面值創建
String garen ="蓋倫";
// 構造方法創建
String teemo = new String("提莫");
// 通過字符數組創建
char[] cs = new char[]{'崔','斯','特'};
String hero = new String(cs);
// 通過 + 加號進行字符串拼接
String hero3 = garen + teemo;
}
}String 被 final 修飾,無法被繼承,而且一旦被創建就不可改變(不能增加長度、不能減少長度、不能插入字符、不能刪除字符、不能修改字符);
常見方法
方法簡介charAt(int index)獲取某索引位置字符toCharArray()將字符串轉換為字符數組subString(int start, int end)獲取索引位置在 [start, end) 的子字符串split(String str)根據分割符將字符串分割為字符串數組trim()去掉首尾空格toLowerCase()全部變成小寫toUpperCase()全部變成大寫indexOf字符或子字符串第一次出現的索引位置lastIndexOf字符或子字符串最后一次出現的索引位置contains字符串是否包含子字符串replaceAll用指定字符串替換目標字符串replaceFirst用指定字符串替換第一個目標字符串startsWith判斷字符串是否以子字符串開始endsWith判斷字符串是否以子字符串結束字符串比較
用 == 比較字符串是否指向同一對象,equals() 方法比較字符串內容是否一樣;
注意特例 :
public class TestString {
public static void main(String[] args) {
String str1 = "the light";
String str2 = new String(str1);
// 用于判斷是否是同一個字符串對象
System.out.println( str1 == str2); // false
// 用于判斷是否是同一個字符串對象
System.out.println(str1.equals(str2)); // true
// 特例,當編譯器遇到字符串字面值時,若發現有重復的,則會直接使用而不再重復創建
String str3 = "the light";
System.out.println( str1 == str3); // true
}
}
StringBuffer
StringBuffer 不同于 String,屬于可變長的字符串,需要經常操作字符串時,StringBuffer 性能更高,常用方法如下:
方法功能append追加delete刪除insert插入reverse反轉length內容長度capacity總空間
public class TestString {
public static void main(String[] args) {
String str1 = "let there ";
// 根據str1創建一個StringBuffer對象
StringBuffer sb = new StringBuffer(str1);
//在最后追加
sb.append("be light");
System.out.println(sb);
// 刪除4-10之間的字符
sb.delete(4, 10);
System.out.println(sb);
// 在4這個位置插入 there
sb.insert(4, "there ");
System.out.println(sb);
// 反轉
sb.reverse();
System.out.println(sb);
// 內容長度
System.out.println(sb.length());
// 總空間
System.out.println(sb.capacity());
}
}
日期
日期格式化SimpleDateFormat 類常用方法
方法功能format日期轉字符串parse字符串轉日期
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* 日期轉字符串
*/
public class TestDate {
public static void main(String[] args) throws Exception{
//y 代表年
//M 代表月
//d 代表日
//H 代表24進制的小時
//h 代表12進制的小時
//m 代表分鐘
//s 代表秒
//S 代表毫秒
SimpleDateFormat sdf =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS" );
Date d= new Date();
String str = sdf.format(d);
System.out.println("當前時間通過 yyyy-MM-dd HH:mm:ss SSS 格式化后的輸出: "+str);
SimpleDateFormat sdf1 =new SimpleDateFormat("yyyy-MM-dd" );
Date d1= new Date();
String str1 = sdf1.format(d1);
System.out.println("當前時間通過 yyyy-MM-dd 格式化后的輸出: "+str1);
}
}
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class TestDate {
public static void main(String[] args) {
SimpleDateFormat sdf =new SimpleDateFormat("yyyy/MM/dd HH:mm:ss" );
String str = "2020/5/1 12:12:12";
try {
Date d = sdf.parse(str);
System.out.printf("字符串 %s 通過格式 yyyy/MM/dd HH:mm:ss %n轉換為日期對象: %s",str,d.toString());
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
總結
以上是生活随笔為你收集整理的java窗口how2j_How2J Java 基础的全部內容,希望文章能夠幫你解決所遇到的問題。
- 上一篇: 如何将原图和json融合_图像语义分割出
- 下一篇: golang mac 环境变量_macO