String字符串，数组

一.String字符串

简单使用API
1.生成自己的api文档
根据自己的java代码生成自己的帮助文档
2。 使用java命令 操作带包的java文件
Javac -d . java文件 编译命令
执行命令 java 全路径（包.Class名）
3.字符串用法
所有的字符串当做变量来使用
数据类型 名字 =值
String str=”hello world”；
字符串是常量；它们的值在创建之后不能改变。
a.字符串的截取
字符串其实是多个字符组成的 123456
使用String提供的方法获取字符串中的子串
一个字符串 可以看做是一组字符组成的
一个字符串 可以看做是对个子字符串组成的
每一个字符串 都有长度

在字符串中 每一个字符都有一个位置 使用标记 0------str.length()
charAt 返回指定索引处的char值

public class Stringmean {
 public static void main(String[] args) {
  String str="abcdefghijkd";
  char c=str.charAt(0);
  System.out.println(c);//a
  //length() 返回此字符串的长度
  System.out.println(str.length());//12
  //indexOf返回指定字符在此字符串中第一次出现处的索引
      System.out.println(str.indexOf("a"));//0
      System.out.println(str.indexOf("a",4));//-1
      //lastIndexOf返回最后一次出现的指定字符在此字符串中的索引
      System.out.println(str.lastIndexOf("d"));//11
      //substring() 返回一个新的字符串，它是此字符串的一个子字符串
      //substring（int beinIndex)/substring（int beinIndex,int endIndex)
      System.out.println(str.substring(4));//efghijkd
      System.out.println(str.substring(4,5));//e
      //toLowerCase()  将此 String 中的所有字符都转换为小写
      System.out.println(str.toLowerCase());//abcdefghijkd
      //toUpperCase() 将此 String 中的所有字符都转换为大写
      System.out.println(str.toUpperCase());//ABCDEFGHIJKD
      //trim() 返回字符串的副本，忽略前导空白和尾部空白
      String str1="    hxryfyxm     ";
      System.out.println("含空格的长度"+str1.length());
      str1=str1.trim();
      System.out.println(str1);
      System.out.println("不含有空格的长度"+str1。length());
      //valueOf() 返回括号内参数的字符串表示形式
      //转换    新的变量接收一下 
      //字符串与数值型转换      数值型转为String型    任意的基本类型转为String类型 
      //  123  转为   “123”  
      int num=123;
      // System.out.println(num+""+100);  
      System.out.println("转换前=="+(num+100));
      String numstr = String.valueOf(num);
      System.out.println("转换后的num值=="+(num+100));
      System.out.println("转换后=="+(numstr+100));
     //获取字符串中的子字符串
      char c =str.charAt(0);
      System.out.println(c);
     //指定字符 在字符串中的位置  使用下标 
      System.out.println("a在str中第一次出现的位置 "+str.indexOf("hello"));
      System.out.println("a在str中最后一次出现的位置 "+str.lastIndexOf("a"));
     //从哪个位置开始找 
     System.out.println("a在str中第一次出现的位置  "+str.indexOf("a",3));
    }
}

b.字符串的比较

//在使用String 的equals方法的时候    
// 如果string变量的值为null   会产生空指针异常 
//可以用一个不为null 的字符串与null的字符串进行比较  
//不要使用值为null的东西与字符串进行比较
public static void main(String[] args) {
   String str1="123";
   String str2="456";
   String str3="123";
   String str4="123456";
   String str5=new String("123");
   String str6=str1+str2;
   String str7=null;
   //==普通方法比较的是值
   System.out.println(str1==str2);
   System.out.println(str1==str3);
   //变量与stringnew方法==比较
   System.out.println("变量与stringnew方法==比较"+str1==str5);
   System.out.println("变量与null方法==比较"+str1==str7);
   System.out.println("变量与两个str拼接方法==比较"+str4==str6);
   //
   System.out.println(str1.equals(str2));
   System.out.println(str1.equals(str4));
   System.out.println(str4.equals(str6));
   System.out.println(str1.equals(str7));
   // java.lang.NullPointerException 空指针异常   
   System.out.println(str7.equals(str1));

在使用String 的equals方法的时候
如果string变量的值为null 会产生空指针异常
可以用一个不为null 的字符串与null的字符串进行比较
不要使用值为null的东西与字符串进行比较

二.数组

数组是用来存放相同数据类型的一个容器，这些相同的数据在容器中是有序排列的。在容器中的数据使用下标来进行标记的。
数组是在程序运行期间用来存放数据的容器
变量：在程序运行期间其值可以改变 存储一个值
数组 ：在程序运行期间内部数据可以改变 存储多个值

//数组的长度一旦声明，在运行期间无法改变
public class array01 {
 public static void main(String[] args) {
  int[] arr = new int[5];// 声明一个int类型的数组
  
  System.out.println("数组的长度为" + arr.length);
  arr[0] = 12;// 给数组的第一个元素赋值
  arr[1] = 44;
  arr[2] = 20;
  arr[4] = 33;
  System.out.println("第一个元素是" + arr[0]);
  System.out.println("第四个元素是" + arr[3]);
  
  // 数组的遍历
  for (int i = 0; i < arr.length; i++) {
   System.out.println("第"+(i+1)+"个元素是" + arr[i]);
  }
  int index = 0;
  for (int j = 0; j < arr.length; j++) {
   System.out.println("第" + index + "个元素是" + arr[index]);
   index++;
  }
 }
}

1 数组的声明
数组的长度 数组中数据的个数
数组中的每一个数据 称为 元素
数组中每一个元素都使用下标来确定它在数组中的位置 0 - 数组的长度-1
语法 ：

类型 [] 数组名字 =new 类型[int value]   声明时给定长度  
类型 [] 数组名字 =new 类型[]{value...}   声明的时候根据实际给数组中方的数据的个数来确定数组的长度     

eg:

//声明一个长度为5的数组，类型是int类型
int[] nums=new int[5];//只有大小和类型，没有具体的数据，拥有默认值
int[] nums={10,20,30}//不推荐使用
//int nums[]          int    []    nums
int nums[]=new int[]{12,20,30,40,50};//在创建的时候就明确数组的长度和数组中的数据

//数组长度的改变
public class array0 {
 public static void main(String[] args) {
  //数组的默认长度是null，数组元素的默认值是根据数组的类型而定
  //GC垃圾回收机制                   new（就会创建一个新的实例 ，保存到堆内容中）
  int [] a=null;
  a=new int[3];
  System.out.println("数组的地址是"+a);
  System.out.println("数组的长度是"+a.length);
  a=new int[5];
  System.out.println("数组的地址是"+a);
  System.out.println("改变后数组的长度是"+a.length);
  int [] temp=new int[3];
  a=temp;
  System.out.println("数组的地址是"+a);
  System.out.println("数组的长度是"+a.length);}}

2.数组的具体使用

数组不能一次给所有元素赋值 只能挨个赋值
数组中可以根据元素的下标给指定位置的元素赋值
数组一旦创建其长度不能改变
a.赋值
b.查询

public class array01 {
 public static void main(String[] args) {
  int[] arr = new int[5];// 声明一个int类型的数组
  
  System.out.println("数组的长度为" + arr.length);
  //赋值
  arr[0] = 12;// 给数组的第一个元素赋值
  arr[1] = 44;
  arr[2] = 20;
  arr[4] = 33;
  //查询（根据下标查询）
  System.out.println("第一个元素是" + arr[0]);
  System.out.println("第四个元素是" + arr[3]);
  
  // 数组的遍历
  for (int i = 0; i < arr.length; i++) {
   System.out.println("第"+(i+1)+"个元素是" + arr[i]);
  }
  int index = 0;
  for (int j = 0; j < arr.length; j++) {
   System.out.println("第" + index + "个元素是" + arr[index]);
   index++;
  }
 }
}

当要查询的数组元素下标的值超过数组的元素下标最大值 报异常 数组元素下标越界异常

3.二维数组----------多维数组
数组中的元素是数组称为二维数组
语法：数据类型 [] 名字 = new 数据类型[5]; String [] stus=new String[5]; 数据类型 [][] 名字 =new 数据类型[3][2];

public class numArray {
 public static void main(String[] args) {
  //院系
  String[][][]yx=new String[2][2][2];
  //创建班级
  String[] stuclass1=new String[] {"stu1","stu2"};
  String[] stuclass2=new String[] {"stu3","stu4"};
  String[] stuclass3=new String[] {"stu5","stu6"};
  String[] stuclass4=new String[] {"stu7","stu8"};
  //创建专业
  String[][] major1=new String[2][2];
  String[][] major2=new String[2][2];
  //数学专业
  major1[0]=stuclass1;
  major1[1]=stuclass2;
  //物理专业
  major2[0]=stuclass3;
  major2[1]=stuclass4;
  //院系
  yx[0]=major1;
  yx[1]=major2;
  System.out.println(yx[0][1][0]);
  //循环
  for (int i = 0; i < yx.length; i++) {
   System.out.println("专业========================");
   for (int j = 0; j <yx[i].length; j++) {
    System.out.println("班级=========================");
    for (int k = 0; k < yx[i][j].length; k++) {
     System.out.println(yx[i][j][k]);
    }
   }
   System.out.println("*************************************");
  }
 }
}

二维数组的子数组的长度是可以发生变化，子数组的实际表示的数组是可以重新赋值的。数组长度不可变，是指你当前所引用的数组的长度不可变，一旦引用发生改变 数组的长度就改变了
数组与数组之间的拷贝

public class ArrayCope {
 public static void main(String[] args) {
  int [] num1=new int[] {10,20,30,40,50};
  int [] num2=new int[] {100,200,300};
  //大数组----小数组
  //小数组----大数组
  //num1----num2把哪些数组赋值过去
  System.out.println("==========num1----num2把哪些数组赋值过去=============");
  for (int i = 0; i < num2.length; i++) {
   num2[i]=num1[i];
   System.out.print(num2[i]+"\t");//10   20   30
  }
    //30  40-----200   300
    //注意一定不要越界
  System.out.print("\n");
  System.out.println("==========30  40-----200   300=============");
    for (int i =1; i < num2.length; i++) {
     num2[i]=num1[i+1];
    }
    //增强for循环（foreach）：将数组全部输出，不能做到单独取几个数
    for (int i : num2) {
     System.out.print(i+"\t");
    }
    System.out.println("\n");
    System.out.println("==========数组的长度=============");
    System.out.println(num1.length+" "+num1[0]);
    System.out.println(num2.length);
  //交换数组的值和长度
    System.out.println("========交换数组的值和长度==============");
    int []temp=null;
    temp=num1;
    num1=num2;
    num2=temp;
    System.out.println(num1.length+" "+num1[0]);
    System.out.println(num2.length);
  }
 }

4.数组的交换
数组的引用交换

5.数组的排序
int[] grand =new int[]{10,5,48,16,20};
排序 ：正序（从小到大asc）和逆序 (从大到小desc)
外层循环控制 需要比较的次数，内层循环是用类每一遍具体比较交换的操作
a.冒泡排序
冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。
依次比较两个相邻的元素，如果是正序 第一比第二大 交换 否则不交换。每一次比较完叫数组中的最大值方法最后。下一次比较的时候就不需要比较上次最大的值。

//每一次实际比较交换的操作  每一次都是从第一个元素开始到上一次最大值前一个
public class maoPaoSort {
 public static void main(String[] args) {
  int []grade=new int[] {4,23,54,18,46};
   System.out.println("=====================排序前===================");
   for (int stu : grade) {//增强for循环，输出grade里面的全部元素
    System.out.print(stu+"     ");
   }
    System.out.println();
   System.out.println("=====================排序====================="); 
   int count=0;
   //外层循环循环一次，内层循环循环一遍
   for (int i = 0; i < grade.length-1; i++) {//外层循环
    for (int j = 0; j < grade.length-1-i; j++) {//内层循环
      if(grade[j]>grade[j+1]) {
      int temp=0;
      temp=grade[j+1];
      grade[j+1]=grade[j];
      grade[j]=temp;
         }
      count++; 
    }
   }
   System.out.println("总共比较的次数是："+count);
   System.out.println("===================排序后==================");
   for (int stu : grade) {
    System.out.print(stu+"      ");
   }
  }
}

b.选择排序
ASC 每一次比较选择一个位置的元素与后面的每一个元素进行比较，如果当前元素比后面的元素大就交换 ， 每一次比较完将本次的最小值放到当前位置。
其实从0小开始，以后的每一次比较都从下一个元素开始

public class chooseSort {
 public static void main(String[] args) {
  int []array=new int[] {45,12,78,66,11,30};
  System.out.println("=====================排序前===================");
  for (int stu : array) {//增强for循环，输出grade里面的全部元素
   System.out.print(stu+"     ");
  }
   System.out.println();
  System.out.println("=====================排序====================="); 
  int count=0;
  //外层循环循环一次，内层循环循环一遍
  for (int i = 0; i < array.length-1; i++) {//外层循环
   for (int j =i; j < array.length-1; j++) {//内层循环
     if(array[i]>array[j+1]) {
        int temp=0;
     temp=array[i];
     array[i]=array[j+1];
     array[j+1]=temp;
        }
     count++; 
   }
  }
  System.out.println("总共比较的次数是："+count);
  System.out.println("===================排序后==================");
  for (int stu : array) {
   System.out.print(stu+"      ");
  }
}
}

public class Sort {
public static void main(String[] args) {
int[] grade = new int[] { 4, 8, 6, 3, 5, 7, 9 };// 声明一个int类型的数组容量为7
  System.out.println("排序前：");
  for (int stu : grade) {// 增强for循环遍历输出
   System.out.print(stu + "   ");
  }
  System.out.println("");
  System.out.println("=========================");
  int compare = 0;// 创建一个标记，记录比较次数
  int exchange = 0;//创建一个标记，记录交换次数
  int i;
  for (i = 0; i < grade.length; i++) {//外层循环控制min标记符的起始下标
   int min = i;// 创建一个标记，记录最小值下标 采用正序
   for (int j = i + 1; j < (grade.length); j++) {//内层控制数组的变化
    if (grade[j] < grade[min]) {//将数组值进行比较
     min = j;//小的一方的索引值由min保存
    }
    compare++;//每比较一次compare数值加一
   }
   if (min != i) {
   int temp = 0;// 定义一个中间变量
    temp = grade[i];// 交换
    grade[i] = grade[min];
    grade[min] = temp;
    exchange++;//每交换一次exchange数值加一
   }
  }
  for (int l : grade) {//输出排序后的数组
   System.out.print(l + "   ");
  }
  System.out.println("");
  System.out.println("比较次数：" + compare);//输出比较次数
  System.out.println("交换次数：" + exchange);//输出交换次数
  }
  }

c.插入排序
1.从第一个元素开始，该元素可以认为已经被排序
2.取出下一个元素，在已经排序的元素序列中从后向前扫描
3.如果该元素（已排序）大于新元素，将该元素移到下一位置
4.重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
5.将新元素插入到该位置后
重复步骤2~5

public class chaRuSort {
  public static void main(String[] args) {
   int[] grade=new int[] {12,14,3,88,45,9};
   System.out.println("=================排序前======================");
   for (int i : grade) {
    System.out.print(i+"      ");
   }
   int i=0;
   int j=0;
   //i=1是因为当数组中只有一个数时，不需要排序，>=2时才需要
   for (i = 1; i < grade.length; i++) {
     int temp=grade[i];//将要比较的第i个元素存到临时变量中
     //如果前一个数比后一个数大，则要转换位置
     if(grade[i-1]>grade[i]) {
       for(j=i-1;j>=0;j--) {
        if(temp<grade[j]) {
         grade[j+1]=grade[j];
         
        }else {
             break;
        }
       }
       grade[j+1]=temp;
     }
   }
   System.out.println("=================排序后======================");
   for (int g : grade) {
    System.out.print(g+"      ");
   }
  }
}

//工具类排序
 public static void main(String[] args) {
  int[] grade=new int[] {12,14,3,88,45,9};
  System.out.println("=================排序前======================");
  for (int i : grade) {
   System.out.print(i+"      ");
  }
  Arrays.sort(grade);
  System.out.println("=================排序后======================");
  for (int g : grade) {
   System.out.print(g+"      ");
  }
 }

d.使用标记进行排序操作