一、字符串
1. 字符串特點
/*
* @字符串最大特點，一旦初始化就不可以改變。
*/
public class StringDemo {
public static void main(String[] args) {
//兩種初始化方式s1 and s2
String s1 = new String("test");//test是一個對象，然後new一個對象。所以是兩個對象。
String s2 = "test";
/*
s1和s2所達到的效果是一樣的，但是他們是有區別的。
區別：s1代表了兩個對象
s2代表了一個對象
*/
System.out.println(s1==s2);
System.out.println(s1.equals(s2));//String類複寫了Objext類中的equals方法，該方法用於判斷兩個字符串是否相等。
}
}
2.字符串常見操作
/*
* @常見的字符串操作。"abcd"。
*
* @1.獲取：
* @int length():獲取字符串長度。
* @char charAt(int index);獲取字符串中某個固定位置的字符。
* @int indexOf(int ch);返回ch第一次在字符串中出現的位置。
* @int indexOf(int ch,int fromIndex);//從fromIndex位置開始，第一次出現ch的位置
* @int indexOf(String str);//返回str字符串第一次出現的位置
* @int indexOf(String str,int fromIndex)//從fromIndex位置開始，第一次出現str的位置
* @int lastIndexOf(char ch)//從右往左查找ch第一次出現的位置
*
* @2.判斷：
* @boolean contains(String str)；//字符串中是否包含str字符串。此處用indexOf也可以達到效果
* @boolean isEmpty();//判斷字符串是夠爲空，即長度是否爲。
* @boolean startsWith(String str)//判斷字符串是夠以str開頭
* @boolean endsWith(String str)//判斷字符串是夠以str結尾
*
*
* @3.轉換:
* @//構造函數
* @String(char[]);//將字符出租轉換爲字符串。
* @String(char[],int offset,int count);//將字符數組中的一部分轉換成字符串。從字符數組中取出從第offset個字符開始的是count個字符，組成一個字符串
*
* @//靜態方法
* @static String copyValueOf(char[],int offset,int count)//效果同上。
*
* @//將字節數組轉換成字符串，將char[]變爲byte[]。
*
* @//將字符串變爲字符數組。****
* @char[] toCharArray();
*
*
* @4.替換:
* @Stringreplace(oldchar,newchar)；//返回的是一個新字符串。如果要替換的字符不存在，返回的還是原字符串。
*
*
* @5.切割：
* @String[] split(regex)；//涉及到正則表達式的點，不能作爲切割字符串的regex。
*
* @6.字串
* @String substring(begin)；//從指定位置開始到結尾。如果角標不存在，會出現字符串角標越界異常。
* @Stringsubstring(begin,end)；//包含頭，不包含尾。
*
* @7.其他：
* @字符串大小寫轉換：
* @StringtoUpperCase();
* @String toLowerCase();
* @去除字符串兩端的空格:
* @String trim();
* @字符串比較://自然順序切割<span id="transmark"></span>
* intcompareTo(String);
*/
public class StringDemo2 {
public static void StringDemo2_get()//獲取演示
{
String str = "abcdefghbj";
sop(str.length());//獲取str的長度
sop(str.charAt(3));//獲取字符串中第三個字符，注意計算機是從0開始計數。但是不能超過總長度，否則會出現越界。
//沒有查找到的時候，返回一個-1.
sop(str.indexOf('b'));//獲取b字符出現的位置。
sop(str.indexOf(2,'a'));//從第二個字符開始查找a出現的位置。
sop(str.lastIndexOf('b'));//從右往左查找b第一次出現的位置
}
public static void StringDemo2_is()//判斷演示
{
String str = "ArrayDemo.java";
//判斷文件名稱是否是Array開頭。
sop(str.startsWith("Array"));
//判斷文件名稱是否是java結尾。
sop(str.endsWith("java"));
//判斷文件中是否包含Demo
sop(str.contains("Demo"));
}
public static void StringDemo2_trans()//轉換演示
{
char[] Arr = {'A','r','r','a','y','D','e','m','o','.','j','a','v','a'};//定義一個字符數組
String s1 = new String(Arr,1,3);//從Arr中取出從第一個字符開始的是三個字符，組成一個字符串
System.out.println(s1);
String s2 = "toArray";
char[] Arr1 = s2.toCharArray();
for(int i = 0; i < Arr1.length; i++)
{
sop("ch="+Arr1[i]);
}
}
public static void sop(Object obj)//1.5版本後新特性，可以傳入基本類型數據。即既可以傳入int類型，也可以傳入string類型。
{
System.out.println(obj);
}
public static void main(String[] args) {
// StringDemo2_get();
StringDemo2_trans();
}
}
二、StringBuffer
string對象只要一旦初始化就不可更改，但是StringBuffer可以。注意：StringBuffer是一個容器，他很多方法都跟String相同，它可以增刪改查。
/*
**@StringBuffer基本操作
* @特點：
* 1.是一個容器 且長度可變，String長度不可變。
* 2.可以字節操作多個數據類型
* 3.最終可以通過Tostring變爲字符串。
*
* @存儲：
* 1.append();將制定數據作爲參數添加到已有數據結尾。
* 2.insert(index,數據);可以將數據插入到指定的index位置。index表示索引位置。
*
* @刪除：
* 1.StringBufferedelete(start,end)：刪除緩衝區中的數據，包含start，不包含end。
* 2.StringBuffer deleteCharAt(index)：刪除指定位置的字符。
* 3.清空緩衝區：對象.delete(0,對象.length());
*
* @獲取：
* 1.char charAt(int index);
* 2.int indexOf(String str);
* 3.int lastIndexOf(String str);
* 4.int length();
* 5.String substring(int start,int end);
*
* @修改：
* 1.StringBuffer replace(int start,int end,String str);
* 2.void setCharAt(int index,char ch);
*
* @反轉：
* StringBuffer reverse();
*
* @將緩衝區中指定數據存儲到指定字符數組中
* voidgetChars(int srcBegin, int srcEnd,char[] dst,int dstBegin);
*
* @StringBuffer和StringBuilder區別
* StringBUffer有鎖，且是線程同步的，效率低下。
* StringBuilder無鎖，不同步，效率高。
* 開發，建議使用StringBuilder。如遇多線程，使用StringBuffer或自己加鎖。
*
*/
public class StringBufferDemo {
public static void main(String[] args) {
StringBuffer str = new StringBuffer();//初始化
str.append("String--").append('c').append(1).append(true);//存儲，裏面的參數可以是字符串，字符，數字，bool值。
sop(str.toString());
StringBuffer str1 = new StringBuffer();
str1.append("abc");
str1.insert(1, "insert");//在1的位置插入一個字符串
sop(str1.toString());
}
public static void sop(String obj)//輸出
{
System.out.println(obj);
}
}
三、基本數據類型對象包裝類。
概述：
/* @基本數據類型對象包裝類:
* byte Byte
* short Short
* int Integer
* long Long
* boolean Boolean
* float Float
* double Double
* char Character
*
* @作用：
* 基本數據類型和字符串類型之間的互相轉換
* 1.基本數據類型黃轉字符串類型
* 基本數據類型.toString(基本數據類型值);如： Integer.toString(32);
* 2.字符串數據類型轉基本數據類型
* xxx a = xxx.parsexxx(String);
* 如：int a = Integer.parseInt("123");
*/
進制轉換：
* 1.十進制轉其他進制：
* toBinaryString();//十進制轉二進制
* toHexString(); //十進制轉十六進制
* toOctalString();//十進制轉八進制
* 2.其他進制轉換
* parseInt(String str,int x);//把x進制類型的str轉換爲10進制。
* 如：parseInt("3c",16);結果爲60
*/
jdk1.5後新特性：
Integer x = new Integer("127")；
Integer y = new Integer("127")；
Integer m = new Integer("128")；
Integern= new Integer("128")；
x==y？：返回true，因爲x，y指向了同一對象。數值在byte範圍內容，對於新特性，如果該數值存在，不會開闢新空間，創建新對象。
m==n？：返回false，byte的範圍是：-128~127
自動裝箱：
Integer x=new Integer(4);//等效於：Integer x=4;
可以直接進行運算：x=x+2;//x進行自動拆箱。變成了int類型。和2進行加法運算。再將和進行裝箱賦給x。這裏需注意的是如果 Integer x=null時候，不能這樣運算，會報異常。x的拆箱動作等效：x.intValue()。
四、練習
<span id="transmark"></span>package String_exam;
/*
* @題目：對一個字符串中的n個數字進行排序，並按從小到大輸出。
* "1,20,5,-3,0,-20,1.5,25,-1.1,0,-3,5"
* 思考：
* 1.用字符串切割對字符串進行切割。
* 2.將其轉換成整數型數組。
* 3.對數組進行快速排序。
* 4.將數組轉換成字符串並打印。
*/
public class String_test {
public static void main(String[] args)
{
String S1 = "1,20,5,-3,0,-20,1.5,25,-1.1,0,-3,5";
System.out.println("排序前---"+S1);
sor(S1);
}
public static void sor(String s)//轉換排序過程
{
//切割字符串並轉換成字符數組
String[] str = s.split(",");
//將字符數組轉換成實數數組
double[] Array1 = stringToDouble(str);
double[] Array2 = stringToDouble(str);
//對此實數型數組進行快速排序或冒泡排序
sort1(Array1, 0, Array1.length-1);//快速排序
sort2(Array2);//冒泡排序
//將數組轉化爲字符串類型
String st1 = DoubleToString(Array1);
String st2 = DoubleToString(Array2);
//輸出結果
System.out.println("快速排序：");
sop(st1);
System.out.println("冒泡排序：");
sop(st2);
}
private static double[] stringToDouble(String[] str)//將字符數組轉換爲數字型數組
{
double[] arr = new double[str.length];
for(int i = 0; i <str.length; i++)
{
arr[i] =Double.parseDouble(str[i]);//字符->實數
}
return arr;
}
private static void sort1(double[] s,int low,int high)//快速排序
{
if(low >= high) return;//當不能再拆分時候返回。
int l = low;//順位標記
int h = high;//逆位標記
double key = s[low];//關鍵數
while(l<h)//當數組的順位上標小於數組逆位上標時候，循環
{
while(l<h&&s[h]>key)//從後向前找小於等於key的值
h--;
if(l<h)
{
s[l] = s[h];//找到值將其賦給s[l]
l++;
}
while(l<h&&s[l]<key)//從前向後找大於等於key的值
l++;
if(l<h)
{
s[h]=s[l];//找到值後將其賦給剛纔空缺的s[h];
}
}
if(l==h) s[l]=key;//第一遍結束，填坑
sort1(s, low, h-1);//對s[l]的前半段進行排序
sort1(s, l+1, high);//對s[l]的後半段進行排序
}
private static void sort2(double[] s)//冒泡選擇排序
{
double temp = 0;
int kk;//記錄最終選擇的數組的下標
for(int i=0;i<s.length-1;i++)
{
kk = 0;
temp = s[i];
for(int j=i+1;j<s.length;j++)
{
if(s[j]<temp)
{
temp = s[j];
kk = j;
}
}
if(kk!=0)
{
s[kk] = s[i];//選擇好了之後再將s[i]與s[kk]交換。
s[i] = temp;
}
}
}
private static String DoubleToString(double[] s)//將數組轉化爲字符串
{
StringBuilder str = new StringBuilder();
for(int i =0; i <s.length;i++)
{
str.append(s[i]+" ");
}
return str.toString();
}
private static void sop(String str)
{
System.out.println(str);
}
}
