String

public class StringDemo1 {

 public static void main(String[] args) {
  /*
   * String演示
   * 1.常量：一旦初始化就不会被改变
   *
   */
  String str="abcd";  //字符串本身 就是一个对象
  //当虚拟机启动的时候，字符串就已经开始存储了，存储在了方法区中的常量池
  String str1 = new String("abcd");
  
  System.out.println(str==str1);//false  比较地址                 new完后是一个新地址
  System.out.println(str1.equals(str));//true   字符串的equals覆盖了object类，
             //比较的是字符串的内容是否相同
  
  //str与str1的区别
  //str在内存中只有一个对象。
   //字符串开始存储了，存储在了方法区中的常量池
  //str1在内存中有两个对象
   //new一个对象，构造方法地址引用，常量池中的那一个
 }

}

字符串比较大小方法： compareTo()
String方法练习
  字符串可以比较大小吗？如果有，将字符串数组排序。
 注意：基本类型数值可以通过比较运算比较大小和相等。>  <  ==
     对象也可以比较是否相等，谁大谁小。都是通过方法完成。
     对象比较相同：Object equals(Object obj):子类一般情况下都会复写，建立自己判断相同的依据。
     对象比大小用的也是方法，该功能有三种情况。所以使用int类型。正数，负数，零
     前者大于后者返回正数，前者小于后者返回负数，前者等于后者返回零。

//String 字符串一旦初始化，就在常量池中，不能改变

public class StringDemo4 {

 public static void main(String[] args) {
  String s1 = "hello";
  String s2 = "java";
  test(s1,s2);
  System.out.println(s1+"..."+s2);
 }

 private static void test(String s1, String s2) {
  s2.replace('a', 'o');       //不会被改变     常量池有三个String对象，hello,java,jovo
  s1=s2;                      //s1指向s2的地址，但是方法出栈后，又返回了
 }
//  s1=s2;
//  System.out.println(s1+"..."+s2);   //写在方法外，s1就会一直指向”java“了
}

练习1：

public class StringDemo5 {

 public static void main(String[] args) {
  /*
   * 需求：子串在整串中出现的次数。”nbasfnbafwefwnbanertetnba“
   * 思路：
   * 1.需要计数。
   * 2.找到一个nba计数器
   * 3.怎么找?那就是在字符串中查找字符串，所以找String类
   * 4.如果有这个方法，每找一次需要计数，需要找n次，循环完成
   *
   * 步骤：
   * 1.定义变量，计数。
   * 2.需要循环，循环条件是，找到了就继续循环，没有找到就停。
   * int indexOf(String)
   * 3.循环内对计数器自增
   *
   */
  String str="nbasfnbafwefwnbanertetnba";
  String key="nba";
  int num=getKeyCount(str,key);
  System.out.println("num="+num);
  
  
 }

 public static int getKeyCount(String str, String key) {
  //1.定义计数器
  int num=0;
  //2.定义每次找到的角标
  int index=0;
  //3.循环，条件是indexOf查找的方法返回的结果不是-1，而且要明确下次查找的位置。indexOf(String,formIndex)
  while((index=str.indexOf(key,index))!=-1)
  {
   num++;
   //每找一次，都要确定下次要找的起始位置。上次位置+key的位置。
   index=key.length();
  }
  return num;
 }

}

练习2：

public class StringDemo6 {

 public static void main(String[] args) {

  /*
   * 需求：两个自字符串的最大相同子串
   * ”aerovncctvamnla“
   * "aesfcctviui"
   *
   * 思路：
   * 1.以短的字符串为主。
   *   到长的字符串中去判断是否存在，如果存在，已找到。
   * 2.如果没有找到，将短的字符串的长度递减获取子串继续到长的串中去找，只要找到就结束。
   * 3.没有找到，说明没有相同的。
   */
  String s1 = "aerovncctvamnla";
  String s2 = "mnsfcctviui";
  String maxSub = getMaxSubString(s1, s2);
  System.out.println("maxsub="+maxSub);
 }

 public static String getMaxSubString(String s1, String s2) {
  //确定哪个是长的哪个是短的
  String longStr,shortStr;
  longStr=s1.length()>s2.length()?s1:s2;
  shortStr=s1.equals(longStr)?s2:s1;
  //对短的字符串操作，从短串中取子串，到长串中去判断
  for(int x=0;x<shortStr.length();x++)
  {
   for (int y = 0,z=shortStr.length()-x;z<=shortStr.length(); y++,z++) {
    String temp = shortStr.substring(y,z);//函数substring()
//    System.out.println(temp);
    if(longStr.contains(temp))//函数Contains()
    {
     return temp;
    }
   }
  }
  
  return null;
 }

}

练习3：

import java.util.Arrays;

public class StringDemo7 {

 public static void main(String[] args) {

  /*
   * 需求：对字符串中的字符进行自然顺序排序
   */
  String str="pkngfvmkacbdf";
  String sortString = sortChar(str);
  System.out.println(sortString);
 }
 /**
  * 对给定的字符串进行字符排序，并返回排序后的字符串。
  *
  */
 public static String sortChar(String str) {
  //1.将字符串转成字符数组
  char[] chs=stringToArray(str);
  //2.对数组排序
  sort(chs);
  //3.将数组转成字符串。
  return toString(chs);
 }
 /*
  * 将字符数组转成字符串
  *
  */
 private static String toString(char[] chs) {
  
  return new String(chs);
 }
 /*
  *对字符数组进行升序排序
  *
  */
 private static void sort(char[] chs) {
  Arrays.sort(chs);
 }
 /*
  * 将字符串转换为字符数组
  *
  */
 private static char[] stringToArray(String str) {
  
  return str.toCharArray();
 }
}