java String类类型的拓展延伸，以及本周知识储备

说到字符串String 就会想起字符char 我们可以把String类型看成是 由char类型数据组成的一个数组char[]，其实java系统内部也就是这么定义的，由于String太实用了，所以这种类类型不需要像Scanner之类的类型用的时候需要创建一个对象，它只需要申明然后直接赋值，用起来简单，当然你用new来创建一个String当然也是可以的，不过会浪费内存，就像包装类里面的Integer Long Character等等一样的......char[] a = {'.......};String str  = new  String[a];String str =null;统统都是可以的，只要是合法的。

当然大家会问学习了String有什么用呢，当然有用呢，下面将两处我觉得对我有用的地方。

例一.手动输入一个英文句子，1.统计出其中单词个数，2，查找出某个字母或者单词出现的次数，下面我就用java语言用不同方式实现它们

class English{
public String inputSentence(){
System.out.println("请输入一句流利英语句子:");
Scanner input = new Scanner(System.in);
String str = input.nextLine();
return str;
}
public static int wordNumberofsentence(String str){
str = str.replace(",", " ");
return str.split(" ").length;
}
public static int numberofoneword(String str,String s){
return str.split(s).length-1;
}
}

实现方式一，利用String类中的spilt方法，spilt(String str) 是把原有的字符串按照str拆分，右边一个子字符串，左边一个子字符串，所以得到的是一个字符串数组，而length则是调用了数组的一个属性。说到spilt 还有一个小点，就是在用spilt分割字符串时候，在用“."|"分割的时候，需要加上通配符\\，不然编译器不识别，将默认你没有分割。

public static String inputSentence(){
System.out.println("请输入一句流利英语句子:");
Scanner input = new Scanner(System.in);
String str = input.nextLine();
return str;
}
public static int wordNumberofsentence(String str){
str = str.replace(",", " ");
int k = 0;
int pos = str.indexOf(' ');

while(pos != -1){
str = str.substring(pos+1);
pos = str.indexOf(' ');
k++;
}
return k+1;


}
public static int numberofoneword(String str,String s){
int k = 0;
int pos = str.indexOf(s);

while(pos != -1){
str = str.substring(pos+s.length());
pos = str.indexOf(s);
k++;
}
return k;

或者用substring(pos) indexOf(String or char)利用这两个方法的配合也可以轻松求出答案，其中substring是字符串切割函数，是将pos位之前的字符串全部丢掉；而indexof则是先看 Str或者s 在不在目标字符串里面 不在则返回-1  在的话就返回第一次它出现的位置pos...

当然这个题目也可以用普通的循环来做，匹配每一个字符串，当然所用资源比前两种要多一些。

接下来就是String类型的数据在计算机内存上是怎么，分配。凡是String类型数据，都是不可变量，一旦你改变了它，那它就不是原来那个它了，String str = "hello";如果你更改了它String str = "hello world";那么内存上又重新分配了一个空间存储str ，原来那个存放hello的空间被遗弃了！！而String a = "hello";String b = "hello",系统就只会开辟一个空间存放"hello"，两个变量名同时指向他而已。。这个和Integer的valueof方法分配值有点像，其范围为-128—127的值，公用一个地址，超出范围的才新建一个Integer存放

第二，这周开始讲数组的概念了，用于存放有序同一数据类型的容器，int[] arrays = new int[];利用数组我们可以操作很多数据，又举两个大家知道的例子吧。快速排序，以及选择排序。

public static int getMiddle(int[] a,int low,int high){
   int temp = a[low];
   while(low<high){
    while(low<high && a[high]>temp){
    high--;
    }
    a[low] = a[high];
    while(low<high && a[low]<temp){
    low++;
    }
    a[high] = a[low];
   }
   a[low] = temp;
return low;
}
public static void _quickSort(int[]a,int low,int high){
if(low<high && a.length>0){
int middle = getMiddle(a,low,high);
_quickSort(a,low,middle-1);
_quickSort(a,middle+1,high);
}
}

快速排序利用的是递归思想，程序自身调用自身，将问题化成若干个小问题解决，当然所付出的代价是浪费了时间节约了空间，接下来所写的就是，选择排序，还是利用数组进行的，其思想就是每一次找出当前数组中最小的一个与当前数组第一位进行交换，当然每一次得到一个最小值，我们的数组就会少一个，下面我直接写出简要代码

public static int[] selectSort(int[] a){

int l = a.length;

for(int i = 0;i<l-1;i++){

int k = i;

int temp = a[0];//每次选最小值时候，先把当前第一个当做是最小的，然后继续往后比较，找出最小，k用于记录最小值得位置pos

for(int j=i+1;j<l-1;j++){

if(a[j]<temp){

temp = a[j];

k = j; 

}

}

a [k]= a[i];

a[i] = temp;//注意这里就是每选出一次当前数组的最小值，就交换当前最小值位置和当前的第一位。

}

}

本周知识积累点：

对于大整数的乘法(当然我当前只是使用的是，把n位数与n位数乘法先用其中一位的每一位数去乘那一个n位数，得到的值加上长度-1个0，然后再把得到的数相加，当然相加函数已经是定义好的，)

public static String bigPlus(String s1,String s2){
int[] a = new int[50];
int[] b = new int[50];
int[] c = new int[50];
int temp = 0;
String result = "";

for (int i = 0; i < s1.length(); i++) {
a[a.length-s1.length()+i] = Integer.parseInt(Character.toString(s1.charAt(i)));
}
for (int i = 0; i < s2.length(); i++) {
b[b.length-s2.length()+i] = Integer.parseInt(Character.toString(s2.charAt(i)));
}
for (int i = 0; i < c.length; i++) {
c[i] = a[i]+b[i];
}

// System.out.println();
// System.out.println(Arrays.toString(c));
for (int i = c.length-1; i >= 0; i--) {
if(c[i] >= 10){
    c[i] = c[i]%10;
    c[i-1] = c[i-1]+1;
}
}


for (int i = 0; i < c.length; i++) {
if(c[i] != 0){
temp = i;
break;
}
}

for (int i = temp; i < c.length; i++) {
result+=c[i];
}
return result;
}

public static String mulNumber(String s1,int s2){
String result = "";
for (int i = 0; i < s2; i++) {
result = bigPlus(result,s1);
}
return result;
}
/**
* 求S1，S2两个大数相乘
* @param s1
* @param s2
* @return
*/
public static String mulBignumber(String s1,String s2){
int leagth = s2.length();
String[] temp = new String[s2.length()];
String result = "";
for (int i = 0; i < s2.length(); i++) {
temp[i] = mulNumber(s1,Integer.parseInt(Character.toString(s2.charAt(i))));
for (int j = 0 ; j < s2.length()-1-i ; j++) {
temp[i] +="0";
}
}
for (int i = 0; i < temp.length; i++) {
result = bigPlus(result,temp[i]);
}
return result;
}
/**
* 将String的数组转换成int型的数组
* @param s1
* @return
*/

public static int[] changeString(String s1){
int[] b = new int[50];
for (int i = 0; i < s1.length(); i++) {
b[b.length-s1.length()+i] = Integer.parseInt(Character.toString(s1.charAt(i)));
}
return b;
}
/**
* 返回数组c的第一个有效数字的下标
* @param c
* @return
*/

public static int getPos(int[] c){
int pos = 0 ;
for (int i = 0; i < c.length; i++) {
if(c[i]!=0){
pos = i;
break;
}
}
return pos;
}

然后看了看   我们以前探讨过得问题，全排列问题，阿克曼函数，以及汉诺塔问题.....这都是我们学到的递归函数的调用，就举一个简单的全排列问题

public static void main(String[] args) {
// TODO 自动生成的方法存根
char[] a = input();
Perm(a,0,a.length-1);
}

public static char[] input(){
System.out.println("请输入一个全排列数据:");
Scanner input = new Scanner(System.in);
String a = input.nextLine();
char p[] = new char[a.length()];
int l = p.length;
for (int i = 0; i < l; i++) {
p[i] = a.charAt(i);
}
return p;
}
/**
* 将数组内下标为i，和下标为k的元素进行交换
* @param a
* @param k
* @param i
*/
public static void swap(char[]a, int k,int i){
char temp = a[k];
a[k] = a[i];
a[i] = temp;
}
/**
* 进行全排列打印  每一次的组合
* @param a
* @param k
* @param m
*/
public static void Perm(char[] a,int k,int m){
if(m == k){
for (int i = 0; i < a.length; i++) {
System.out.print(a[i]);
}
System.out.println();
}else{
for(int i = k; i < a.length; i++) {
swap(a,k,i);
// char temp;
// temp = a[i];
// a[i] = a[k];
// a[k] = temp;
Perm(a,k+1,m);
swap(a,k,i);//当时以为java不能写交换函数，因为交换函数毕竟交换的是地址，不过看了老师的方法，知道了可以用数组作为传入值，就有参考地址了....
// char temp2;
// temp2 = a[i];
// a[i] = a[k];
// a[k] = temp2;
}
}
}

而，汉诺塔问题也就是和斐波那契数列（F3=F1+F2）一样的问题，f2 = 2*f1+1；显然汉诺塔的增长速度和他不相伯仲，也就有了梵天的典故呢=.=.....64层汉诺塔移动位置需要几千亿年（若一秒移动一次），多么夸张的数据......好吧这周就这些了，下周继续学习