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融合_图像语义分割出
- 下一篇： hashmap移除元素_Java Has