eclipse使用的步驟：

1.選擇工作目錄。以後在Eclipse上面寫的所有代碼都是在工作目錄上的

2.在Project Exploer窗口上新建一個工程，以後我們寫代碼都是以工程為單位的

3.在工程的src目錄下右擊，new一個class或者一個package

　　工程的目錄介紹：

1. settings：eclipse自動生成的配置文件，別碰它
2. bin：用於存放所有的class文件
3. src：用於存放所有的java源文件
4. 運行java文件
5. 導入工程

運行有三種方式：

1. java的源代碼右擊——————>run as————————>java application
2. 綠色箭頭的右邊向下箭頭——————>run as————————>java application
3. Ctrl+F11

使用eclipse的好處：

1. ctrl+/ 內容補全
2. 不需要你在使用javac工具編譯，你在eclipse上面一旦保存，Eclipse自動編譯
3. 精準報錯，自動修復（ctrl+1）

Object類是所有類的終極父類。任何一個類都繼承了Object類

Object類：

常用的方法：

1. toString()方法 返回該對象的字符串表示 返回的字符串表示：完整類名+@+對象的哈希碼
2. equals（Object obj）方法 用於比較兩個對象的內存地址，判斷兩個對象是否為同一個對象
3. hashcode（）方法 返回該對象的哈希碼值

疑問：toString（）方法有什麽作用？

查看源代碼的方式：

　　　　方式一：按住ctrl鍵單擊你需要看的源代碼

　　　　方式二：把光標移動到你需要查看的代碼處按下F3

這時候，我們就有了疑問，為什麽要查看源代碼呢？

1. 查看源代碼可以了解別人是如何寫出這個技術的，讓我們了解的更加的深入
2. 吸收大牛的思想

看源代碼最忌諱的一點：不要每行代碼都弄懂是什麽意思，能看個大概猜出他意思就足以

例題：改寫toString方法

public class Demo1 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Demo1 d=new
 
 Demo1();
        System.out.println("hashcode="+d.hashCode());
        Object o=new Object();
        System.out.println("toString:"+o.toString());  //toString:java.lang.Object@2c13da15
        System.out.println(o);
        Person p1=new Person(110,"狗娃");
        System.out.println(p1);
        Person p2=new Person(120,"狗蛋");
        System.out.println(p2);
    }

}
class Person{
    int id;
    String name;
    public Person() {}
    public Person(int id,String name) {
        this.id=id;
        this.name=name;
    }
    public String toString() {
        return "編號："+this.id+"姓名："+this.name;
    }
}

結果：
hashcode=1361960727
toString:java.lang.Object@2c13da15
java.lang.Object@2c13da15
編號：110姓名：狗娃
編號：120姓名：狗蛋

經過這次例題，我們可以看出，重寫toString之後，我們直接輸出一個對象的時候，就會輸出符合我們需求的格式數據

重寫equals（）方法

@Override
    public boolean equals(Object obj) {
    // TODO Auto-generated method stub
        Person p=(Person)obj;
         return this.id==p.id;
    }


結果：
p1與p2是同一個對象嗎？true

java種的規範：一般我們重寫了一個類的equals方法我們都會重寫它的hashcode方法。

@Override
    public int hashCode() {
        // TODO Auto-generated method stub
        return this.id;
    }

System.out.println("p1哈希碼:"+p1.hashCode());
        System.out.println("p2哈希碼:"+p2.hashCode());

結果：
p1哈希碼:110
p2哈希碼:110

這是因為比如equals方法返回為true，但是hashcode返回的值不一樣，這就讓人看起來很難受。

String 字符串類：

筆試題目：new String（"abc"）創建了幾個對象

兩個對象，一個對象是位於字符串常量中，一個對象是位於堆內存中。

使用equals方法的時候，我們一般都會將常量作為方法的調用者，這樣避免空指針異常

test(null);

public static void test(String str) {
        if ("中國".equals(str)) {
            System.out.println("回答正確");
        }
        else {
            System.out.println("回答錯誤");
        }
    }

結果：
回答錯誤

String類的構造方法：

String（）　　創建一個空內容的字符串對象。

String str=new String();

String（byte[] bytes） 使用一個字節數組構建一個字符串對象

public static void main(String[] args) {
        // TODO Auto-generated method stub
        String str=new String();
        byte[] buf= {97,98,99};
        str=new String(buf);
        System.out.println("字符串的內容是："+str);
    }

結果：
字符串的內容是：abc

String(byte[] bytes, int offset, int length)

bytes:要解碼的數組

offset：指定從數組中哪個索引值開始解碼。

length：要解碼多少個字符

str=new String(buf,1,2);
        System.out.println("字符串的內容是："+str);

結果：
字符串的內容是：bc

String(char[] value) 使用一個字符數組構建一個字符串

String(char[] value, int offset, int count) 使用一個字符數組構建一個字符串，然後從給的的索引值開始，解碼length個字符

char[] arr= {‘明‘,‘天‘,‘會‘,‘更‘,‘好‘};
        str=new String(arr);
        System.out.println("字符串的內容是："+str);

結果：
字符串的內容是：明天會更好

String(int[] codePoints, int offset, int count) int類型的索引

String(String original) 初始化一個新創建的String對象，使其表示一個與參數相同的字符序列；換句話說，新創建的字符串是該參數字符串的副本

記住：使用字節數組或者字符數組都可以構建一個字符串對象。

獲取方法：

int length 獲取字符串的長度

char charAt（int index）獲取特定位置的字符（角標越界）

int indexOf（String str）查找字串第一次出現的索引值，如果字串沒有出現在字符串中，那麽則返回-1表示。

int lastIndexOf(String str) 獲取最後一個字符的位置，如果字串沒有出現在字符串中，那麽則返回-1表示。

public static void main(String[] args) {
        // TODO Auto-generated method stub
        String str="abc中國ab中國";
        System.out.println("字符串的字符個數："+str.length());
        System.out.println("根據索引值獲取對應的字符："+str.charAt(3));
        System.out.println("查找字串第一次出現的索引值："+str.indexOf("中國"));
        System.out.println("查找字串第一次出現的索引值："+str.lastIndexOf("中國"));
    }

結果：
字符串的字符個數：9
根據索引值獲取對應的字符：中
查找字串第一次出現的索引值：3
查找字串第一次出現的索引值：7

判斷方法：

boolean endsWith（String str） 是否以指定字符串結束

boolean isEmpty（） 是否長度為0

boolean contains（CharSequences） 是否包含指定序列 應用：搜索

boolean equals（Object anObject） 是否相等

boolean equalsIgnoreCase（String anotherString）忽略大小寫是否相等

public static void main(String[] args) {
        // TODO Auto-generated method stub
        String str="Demo.java";
        System.out.println("是否以指定的字符串結束:"+str.endsWith("java"));
        System.out.println("判斷字符串是否為空內容："+str.isEmpty());
        System.out.println("判斷字符串是否包含指定的內容"+str.contains("De"));
        System.out.println("判斷兩個字符串的內容是否一致："+"DEMO.JAVA".equals(str));  //區分大小寫
        System.out.println("判斷兩個字符串的內容是否一致（忽略大小寫比較）"+"demo.java".equalsIgnoreCase(str));
    }

結果：
是否以指定的字符串結束:true
判斷字符串是否為空內容：false
判斷字符串是否包含指定的內容true
判斷兩個字符串的內容是否一致：false
判斷兩個字符串的內容是否一致（忽略大小寫比較）true

轉換方法：

String （char【】 value） 將字符數組轉換為字符串

String （char【】value，int offset，int count）

static String valueOf（char[] data）

static String valueOf（char[] data,int offst,int count）

char[] toCharArray() 將字符串轉化為字符數組

byte[] getBytes（）

字節數組，字符數組，字符串它們三者之間是可以互相轉換的。

char[] buf=str.toCharArray();  //轉換為字符數組
        System.out.println("字符數組："+Arrays.toString(buf));
        byte[] buf2=str.getBytes();
        System.out.println("字節數組："+Arrays.toString(buf2));

結果:
字符數組：[D, e, m, o, ., j, a, v, a]
字節數組：[68, 101, 109, 111, 46, 106, 97, 118, 97]

String replace(char oldChar,char newChar) 替換 也可以傳兩個字符串

String【】split（String regex）切割

String substring（int beginIndex） 截取字串

String substring（int beginIndex，int endIndex） 截取字符串

String toUpperCase（） 轉大寫

String toLowerCase（）轉小寫

String trim（） 去除字符串首尾的空格　　

import java.util.*;
public class Demo6 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String str="今天晚上不考試";
        System.out.println("指定新內容替換舊的內容："+str.replace("不", "要"));
        System.out.println("指定新內容替換舊的內容："+str.replace("不", "要好好"));
        str="大家-下-午-好";
        String[] arr=str.split("-");
        System.out.println("字符串數組："+Arrays.toString(arr));
        str="廣州傳智播客";
        System.out.println("指定開始的索引值截取子串："+str.substring(2));
        System.out.println("指定開始和結束的索引值截取子串："+str.substring(2,4));//包頭不包尾 註意：截取的內容是包括開始的索引值，不包括結束的索引值，截取的位置是結束的位置-1位
        str="abcde中國";
        System.out.println("轉大寫："+str.toUpperCase());
        str="ASsdadaHGKda";
        System.out.println("轉小寫："+str.toLowerCase());
        str="            大家最近       都非常  努力            ";
        System.out.println("去除字符串首尾的空格："+str.trim());
    }

}

結果：

指定新內容替換舊的內容：今天晚上要考試
指定新內容替換舊的內容：今天晚上要好好考試
字符串數組：[大家, 下, 午, 好]
指定開始的索引值截取子串：傳智播客
指定開始和結束的索引值截取子串：傳智
轉大寫：ABCDE中國
轉小寫：assdadahgkda
去除字符串首尾的空格：大家最近       都非常  努力

例1：自己重寫Tirm方法

public class Demo7 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String str="            傳智         播客          ";
        System.out.println("字符串："+str);
        System.out.println("去除空格後的字串："+myTirm(str));
    }
    public static String myTirm(String str) {
        //先轉換字符數組
        char[] arr=str.toCharArray();
        //定義兩個變量記錄開始的索引值與結束的索引值
        int startIndex=0;
        int endIndex=arr.length-1;
        //確定開始的索引值
        while (true) {
            if (arr[startIndex]==‘ ‘) {
                startIndex++;
            }
            else {
                break;
            }
        }
        //確定結束的索引值
        while (true) {
            if (arr[endIndex]==‘ ‘) {
                endIndex--;
            }
            else {
                break;
            }
        }
        //截取子串返回
        return str.substring(startIndex, endIndex+1);
    }
}

結果;
字符串：            傳智         播客          
去除空格後的字串：傳智         播客

例2：從一串文件名中獲取文件名稱

public static void getFileName(String path) {
        int index=path.lastIndexOf("\\");
        String fileName=path.substring(index+1);
        System.out.println("文件名："+fileName);
    }

str="D:\\20120512\\day12\\Demo1.java";
        getFileName(str);

結果：
文件名：Demo1.java

例3：將字符串對象中存儲的字符反序

public static String reverse(String str) {
        char[] arr=str.toCharArray();
        char[] arr2=new char[arr.length];
        int index=0;
        for (int i=arr.length-1;i>=0;i--) {
            arr2[index++]=arr[i];
        }
        String str2=new String(arr2);
        return str2;
    }

str="新中國好";
        System.out.println("倒置後的字符串："+reverse(str));

結果：
倒置後的字符串：好國中新

例4：統計子串出現的個數

public static void getCount(String str,String target) {
        int count=0;  //用於記錄出現的次數
        int fromIndex=0;  //記錄從哪個索引值開始尋找目標字串
        while (str.indexOf(target, fromIndex)!=-1) {
            //如果indexOf返回的不是-1，那麽意味著找到了目標元素
            fromIndex=str.indexOf(target, fromIndex);
            count++;
            fromIndex=fromIndex+target.length();
        }
        System.out.println("出現的次數："+count);
    }

str="abcjavaabcjavajavaphpjava";
        getCount(str,"java");

結果：
出現的次數：4

字符串特點：字符串是常量，他們的值在創建之後不能更改

字符串的內容一旦發生變化，那麽馬上會創建一個新的對象

註意：字符串的內容不適宜頻繁修改，因為一旦修改馬上就會創建一個新的對象。

如果需要頻繁修改字符串的內容，建議使用字符串緩沖類（StringBuffer）。

StringBuffer 其實就是一個存儲字符的容器。

添加數據：append（）；

StringBuffer底層是依賴了一個字符數組才能存儲字符數據的，該字符串數組默認的初始容量是16，如果字符數組的長度不夠使用時，自動增長一倍

容器應該具備的行為: 增刪查改判斷

Java學習筆記（12）