24H免费课程咨询  TEL:13401595960   QQ:1870218756  微信:13401595960(李老师)

东方博宜

网站首页 > 软件开发资讯 > Java开发

Java常见类解析:Object、Integer、String等

2017-06-24 19:34:13 东方博宜 阅读

1:object类的讲解



package cn.itcast_01;


public class Student extends Object {

}

package cn.itcast_01;

/*
 * Object:类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。
 * 每个类都直接或者间接的继承自Object类。
 *
 * Object类的方法:
 *   public int hashCode():返回该对象的哈希码值。
 *    注意:哈希值是根据哈希算法计算出来的一个值,这个值和地址值有关,但是不是实际地址值。
 *               你可以理解为地址值。


 *
 *  public final Class getClass():返回此 Object 的运行时类
 *   Class类的方法:
 *    public String getName():以 String 的形式返回此 Class 对象所表示的实体
 */
public class StudentTest {
 public static void main(String[] args) {
  Student s1 = new Student();
  System.out.println(s1.hashCode()); // 11299397
  Student s2 = new Student();
  System.out.println(s2.hashCode());// 24446859
  Student s3 = s1;
  System.out.println(s3.hashCode()); // 11299397
  System.out.println("-----------");

  Student s = new Student();
  Class c = s.getClass();
  String str = c.getName();
  System.out.println(str); // cn.itcast_01.Student
  
  //链式编程
  String str2  = s.getClass().getName();
  System.out.println(str2);
 }
}

 

2 Integer类



package cn.itcast_02;

public class Student {
 private String name;
 private int age;

 public Student() {
  super();
 }

 public Student(String name, int age) {
  super();
  this.name = name;
  this.age = age;
 }

 public String getName() {
  return name;
 }

 public void setName(String name) {
  this.name = name;
 }

 public int getAge() {
  return age;
 }

 public void setAge(int age) {
  this.age = age;
 }

 @Override
 public String toString() {
  return "Student [name=" + name + ", age=" + age + "]";
 }

 // @Override
 // public String toString() {
 // // return super.toString();
 // // return "hello";
 // return "姓名:" + name + ",年龄:" + age;
 // }
 
 
}

 

package cn.itcast_02;

/*
 * public String toString():返回该对象的字符串表示。
 *
 * Integer类下的一个静态方法:
 *   public static String toHexString(int i):把一个整数转成一个十六进制表示的字符串
 *
 * 这个信息的组成我们讲解完毕了,但是这个信息是没有任何意义的。所以,建议所有子类都重写该方法。
 * 怎么重写呢?
 *   把该类的所有成员变量值组成返回即可。
 * 重写的最终版方案就是自动生成toString()方法。
 *
 * 注意:
 *   直接输出一个对象的名称,其实就是调用该对象的toString()方法。
 */
public class StudentDemo {
 public static void main(String[] args) {
  Student s = new Student();
  System.out.println(s.hashCode());
  System.out.println(s.getClass().getName());
  System.out.println("--------------------");
  System.out.println(s.toString());// cn.itcast_02.Student@42552c
  System.out.println("--------------------");
  // toString()方法的值等价于它
  // getClass().getName() + '@' + Integer.toHexString(hashCode())
  // this.getClass().getName()+'@'+Integer.toHexString(this.hashCode())

  // cn.itcast_02.Student@42552c
  // cn.itcast_02.Student@42552c

  System.out.println(s.getClass().getName() + '@'
    + Integer.toHexString(s.hashCode()));

  System.out.println(s.toString());

  // 直接输出对象的名称
  System.out.println(s);
 }
}



package cn.itcast_03;

public class Student {
 private String name;
 private int age;

 public Student() {
  super();
 }

 public Student(String name, int age) {
  super();
  this.name = name;
  this.age = age;
 }

 public String getName() {
  return name;
 }

 public void setName(String name) {
  this.name = name;
 }

 public int getAge() {
  return age;
 }

 public void setAge(int age) {
  this.age = age;
 }

 @Override
 public boolean equals(Object obj) {
  if (this == obj)
   return true;
  if (obj == null)
   return false;
  if (getClass() != obj.getClass())
   return false;
  Student other = (Student) obj;
  if (age != other.age)
   return false;
  if (name == null) {
   if (other.name != null)
    return false;
  } else if (!name.equals(other.name))
   return false;
  return true;
 }
 
// @Override
// public boolean equals(Object obj) {
//  // return true;
//  //这里要改进,根据这里比较的成员变量来决定返回true还是false
//  //这里其实要比价的就是name和age
//  //但是,name是String类型的,而String是引用类型的,所以,在这里不能直接用==比较,应该用equals()比较
//  //String的equals()方法是重写自Object类的,比较的是字符串的内容是否相同
//  //this -- s1
//  //obj -- s2
//  //我们要使用的是学生类的特有成员变量,所以要向下转型
//  Student s = (Student)obj; //s -- obj -- s2;
//  if(this.name.equals(s.name) && this.age == s.age) {
//   return true;
//  }else {
//   return false;
//  }
// }
 
// @Override
// public boolean equals(Object obj) {
//  //为了提高效率
//  if(this == obj){
//   return true;
//  }
//  
//  //为了提供程序的健壮性
//  //我先判断一下,obj是不是学生的一个对象,如果是,再做向下转型,如果不是,直接返回false。
//  //这个时候,我们要判断的是对象是否是某个类的对象?
//  //记住一个格式:对象名 instanceof 类名
//  //表示:判断该对象名是否是该类名一个对象
//  if(!(obj instanceof Student)){
//   return false;
//  }
//  //如果是就继续
//  
//  Student s = (Student)obj;
//  //System.out.println("同一个对象,还需要向下转型并比较吗?");
//  return this.name.equals(s.name) && this.age == s.age;
// }
 
 
}

 

package cn.itcast_03;

/*
 * public boolean equals(Object obj):指示其他某个对象是否与此对象“相等”。
 * 这个方法,默认情况下比较的是地址值。比较地址值一般来说意义不大,所以我们要重写该方法。
 * 怎么重写呢?
 *   一般都是用来比较对象的成员变量值是否相同。
 * 重写的代码优化:提高效率,提高程序的健壮性。
 * 最终版:
 *   其实还是自动生成。
 *
 * 看源码:
 *   public boolean equals(Object obj) {
 *    //this - s1
 *    //obj - s2
 *        return (this == obj);
 *    }
 *
 * ==:
 *   基本类型:比较的就是值是否相同
 *   引用类型:比较的就是地址值是否相同
 * equals:
 *   引用类型:默认情况下,比较的是地址值。
 *   不过,我们可以根据情况自己重写该方法。一般重写都是自动生成,比较对象的成员变量值是否相同
 */
public class StudentDemo {
 public static void main(String[] args) {
  Student s1 = new Student("林青霞", 27);
  Student s2 = new Student("林青霞", 27);
  System.out.println(s1 == s2); // false
  Student s3 = s1;
  System.out.println(s1 == s3);// true
  System.out.println("---------------");

  System.out.println(s1.equals(s2)); // obj = s2; //false
  System.out.println(s1.equals(s1)); // true
  System.out.println(s1.equals(s3)); // true
  Student s4 = new Student("风清扬",30);
  System.out.println(s1.equals(s4)); //false
  
  Demo d = new Demo();
  System.out.println(s1.equals(d)); //ClassCastException

 }
}

class Demo {}

 




package cn.itcast_04;

public class Student implements Cloneable {
 private String name;
 private int age;

 public Student() {
  super();
 }

 public Student(String name, int age) {
  super();
  this.name = name;
  this.age = age;
 }

 public String getName() {
  return name;
 }

 public void setName(String name) {
  this.name = name;
 }

 public int getAge() {
  return age;
 }

 public void setAge(int age) {
  this.age = age;
 }
 
 @Override
 protected Object clone() throws CloneNotSupportedException {
  return super.clone();
 }
}

 

package cn.itcast_04;

/*
 * protected void finalize():当垃圾回收器确定不存在对该对象的更多引用时,由对象的垃圾回收器调用此方法。用于垃圾回收,但是什么时候回收不确定。
 * protected Object clone():创建并返回此对象的一个副本。
 *  A:重写该方法
 *
 *  Cloneable:此类实现了 Cloneable 接口,以指示 Object.clone() 方法可以合法地对该类实例进行按字段复制。
 *   这个接口是标记接口,告诉我们实现该接口的类就可以实现对象的复制了。
 */
public class StudentDemo {
 public static void main(String[] args) throws CloneNotSupportedException {
  //创建学生对象
  Student s = new Student();
  s.setName("林青霞");
  s.setAge(27);
  
  //克隆学生对象
  Object obj = s.clone();
  Student s2 = (Student)obj;
  System.out.println("---------");
  
  System.out.println(s.getName()+"---"+s.getAge());
  System.out.println(s2.getName()+"---"+s2.getAge());
  
  //以前的做法
  Student s3 = s;
  System.out.println(s3.getName()+"---"+s3.getAge());
  System.out.println("---------");
  
  //其实是有区别的
  s3.setName("刘意");
  s3.setAge(30);
  System.out.println(s.getName()+"---"+s.getAge());
  System.out.println(s2.getName()+"---"+s2.getAge());
  System.out.println(s3.getName()+"---"+s3.getAge());
  
 }
}




1:Eclipse的概述使用(掌握)
 请参照ppt和课堂练习.txt
 
2:API的概述(了解)
 (1)应用程序编程接口。
 (2)就是JDK提供给我们的一些提高编程效率的java类。

3:Object类(掌握)
 (1)Object是类层次结构的根类,所有的类都直接或者间接的继承自Object类。
 (2)Object类的构造方法有一个,并且是无参构造
  这其实就是理解当时我们说过,子类构造方法默认访问父类的构造是无参构造
 (3)要掌握的方法:
  A:toString()
   返回对象的字符串表示,默认是由类的全路径+'@'+哈希值的十六进制表示。
   这个表示其实是没有意义的,一般子类都会重写该方法。
   如何重写呢?过程我也讲解过了,基本上就是要求信息简单明了。
   但是最终还是自动生成。
  B:equals()
   比较两个对象是否相同。默认情况下,比较的是地址值是否相同。
   而比较地址值是没有意义的,所以,一般子类也会重写该方法。
   重写过程,我也详细的讲解和分析了。
   但是最终还是自动生成。
 (4)要了解的方法:
  A:hashCode() 返回对象的哈希值。不是实际地址值,可以理解为地址值。
  B:getClass() 返回对象的字节码文件对象,反射中我们会详细讲解 
  C:finalize() 用于垃圾回收,在不确定的时间
  D:clone() 可以实现对象的克隆,包括成员变量的数据复制,但是它和两个引用指向同一个对象是有区别的。
 (5)两个注意问题;
  A:直接输出一个对象名称,其实默认调用了该对象的toString()方法。
  B:面试题
   ==和equals()的区别?
   A:==
    基本类型:比较的是值是否相同
    引用类型:比较的是地址值是否相同
   B:equals()
    只能比较引用类型。默认情况下,比较的是地址值是否相同。
    但是,我们可以根据自己的需要重写该方法。

 




3:Scanner类

package cn.itcast_01;

/*
 * Scanner:用于接收键盘录入数据。
 *
 * 前面的时候:
 *   A:导包
 *   B:创建对象
 *   C:调用方法
 *
 * System类下有一个静态的字段:
 *   public static final InputStream in; 标准的输入流,对应着键盘录入。
 *
 *   InputStream is = System.in;
 *
 * class Demo {
 *   public static final int x = 10;
 *   public static final Student s = new Student();
 * }
 * int y = Demo.x;
 * Student s = Demo.s;
 *
 *
 * 构造方法:
 *   Scanner(InputStream source)
 */
import java.util.Scanner;

public class ScannerDemo {
 public static void main(String[] args) {
  // 创建对象
  Scanner sc = new Scanner(System.in);

  int x = sc.nextInt();
  
  System.out.println("x:" + x);
 }
}



package cn.itcast_02;

import java.util.Scanner;

/*
 * 基本格式:
 *   public boolean hasNextXxx():判断是否是某种类型的元素
 *   public Xxx nextXxx():获取该元素
 *
 * 举例:用int类型的方法举例
 *   public boolean hasNextInt()
 *   public int nextInt()
 *
 * 注意:
 *   InputMismatchException:输入的和你想要的不匹配
 */
public class ScannerDemo {
 public static void main(String[] args) {
  // 创建对象
  Scanner sc = new Scanner(System.in);

  // 获取数据
  if (sc.hasNextInt()) {
   int x = sc.nextInt();
   System.out.println("x:" + x);
  } else {
   System.out.println("你输入的数据有误");
  }
 }
}



package cn.itcast_03;

import java.util.Scanner;

/*
 * 常用的两个方法:
 *   public int nextInt():获取一个int类型的值
 *   public String nextLine():获取一个String类型的值
 *
 * 出现问题了:
 *   先获取一个数值,在获取一个字符串,会出现问题。
 *   主要原因:就是那个换行符号的问题。
 * 如何解决呢?
 *   A:先获取一个数值后,在创建一个新的键盘录入对象获取字符串。
 *   B:把所有的数据都先按照字符串获取,然后要什么,你就对应的转换为什么。
 */
public class ScannerDemo {
 public static void main(String[] args) {
  // 创建对象
  Scanner sc = new Scanner(System.in);

  // 获取两个int类型的值
  // int a = sc.nextInt();
  // int b = sc.nextInt();
  // System.out.println("a:" + a + ",b:" + b);
  // System.out.println("-------------------");

  // 获取两个String类型的值
  // String s1 = sc.nextLine();
  // String s2 = sc.nextLine();
  // System.out.println("s1:" + s1 + ",s2:" + s2);
  // System.out.println("-------------------");

  // 先获取一个字符串,在获取一个int值
  // String s1 = sc.nextLine();
  // int b = sc.nextInt();
  // System.out.println("s1:" + s1 + ",b:" + b);
  // System.out.println("-------------------");

  // 先获取一个int值,在获取一个字符串
  // int a = sc.nextInt();
  // String s2 = sc.nextLine();
  // System.out.println("a:" + a + ",s2:" + s2);
  // System.out.println("-------------------");

  int a = sc.nextInt();
  Scanner sc2 = new Scanner(System.in);
  String s = sc2.nextLine();
  System.out.println("a:" + a + ",s:" + s);
 }
}

4:String类




package cn.itcast_01;

/*
 * 字符串:就是由多个字符组成的一串数据。也可以看成是一个字符数组。
 * 通过查看API,我们可以知道
 *   A:字符串字面值"abc"也可以看成是一个字符串对象。
 *   B:字符串是常量,一旦被赋值,就不能被改变。
 *
 * 构造方法:
 *   public String():空构造
 *  public String(byte[] bytes):把字节数组转成字符串
 *  public String(byte[] bytes,int index,int length):把字节数组的一部分转成字符串
 *  public String(char[] value):把字符数组转成字符串
 *  public String(char[] value,int index,int count):把字符数组的一部分转成字符串
 *  public String(String original):把字符串常量值转成字符串
 *
 * 字符串的方法:
 *   public int length():返回此字符串的长度。
 */
public class StringDemo {
 public static void main(String[] args) {
  // public String():空构造
  String s1 = new String();
  System.out.println("s1:" + s1);
  System.out.println("s1.length():" + s1.length());
  System.out.println("--------------------------");

  // public String(byte[] bytes):把字节数组转成字符串
  byte[] bys = { 97, 98, 99, 100, 101 };
  String s2 = new String(bys);
  System.out.println("s2:" + s2);
  System.out.println("s2.length():" + s2.length());
  System.out.println("--------------------------");

  // public String(byte[] bytes,int index,int length):把字节数组的一部分转成字符串
  // 我想得到字符串"bcd"
  String s3 = new String(bys, 1, 3);
  System.out.println("s3:" + s3);
  System.out.println("s3.length():" + s3.length());
  System.out.println("--------------------------");

  // public String(char[] value):把字符数组转成字符串
  char[] chs = { 'a', 'b', 'c', 'd', 'e', '爱', '林', '亲' };
  String s4 = new String(chs);
  System.out.println("s4:" + s4);
  System.out.println("s4.length():" + s4.length());
  System.out.println("--------------------------");

  // public String(char[] value,int index,int count):把字符数组的一部分转成字符串
  String s5 = new String(chs, 2, 4);
  System.out.println("s5:" + s5);
  System.out.println("s5.length():" + s5.length());
  System.out.println("--------------------------");
  
  //public String(String original):把字符串常量值转成字符串
  String s6 = new String("abcde");
  System.out.println("s6:" + s6);
  System.out.println("s6.length():" + s6.length());
  System.out.println("--------------------------");
  
  //字符串字面值"abc"也可以看成是一个字符串对象。
  String s7 = "abcde";
  System.out.println("s7:"+s7);
  System.out.println("s7.length():"+s7.length());
 }
}




package cn.itcast_02;

/*
 * 字符串的特点:一旦被赋值,就不能改变。
 */
public class StringDemo {
 public static void main(String[] args) {
  String s = "hello";
  s += "world";
  System.out.println("s:" + s); // helloworld
 }
}



package cn.itcast_02;

/*
 * String s = new String(“hello”)和String s = “hello”;的区别?
 * 有。前者会创建2个对象,后者创建1个对象。
 *
 * ==:比较引用类型比较的是地址值是否相同
 * equals:比较引用类型默认也是比较地址值是否相同,而String类重写了equals()方法,比较的是内容是否相同。
 */
public class StringDemo2 {
 public static void main(String[] args) {
  String s1 = new String("hello");
  String s2 = "hello";

  System.out.println(s1 == s2);// false
  System.out.println(s1.equals(s2));// true
 }
}



package cn.itcast_02;

/*
 * 看程序写结果
 */
public class StringDemo3 {
 public static void main(String[] args) {
  String s1 = new String("hello");
  String s2 = new String("hello");
  System.out.println(s1 == s2);// false
  System.out.println(s1.equals(s2));// true

  String s3 = new String("hello");
  String s4 = "hello";
  System.out.println(s3 == s4);// false
  System.out.println(s3.equals(s4));// true

  String s5 = "hello";
  String s6 = "hello";
  System.out.println(s5 == s6);// true
  System.out.println(s5.equals(s6));// true
 }
}



package cn.itcast_02;

/*
 * 看程序写结果
 * 字符串如果是变量相加,先开空间,在拼接。
 * 字符串如果是常量相加,是先加,然后在常量池找,如果有就直接返回,否则,就创建。
 */
public class StringDemo4 {
 public static void main(String[] args) {
  String s1 = "hello";
  String s2 = "world";
  String s3 = "helloworld";
  System.out.println(s3 == s1 + s2);// false
  System.out.println(s3.equals((s1 + s2)));// true

  System.out.println(s3 == "hello" + "world");// false 这个我们错了,应该是true
  System.out.println(s3.equals("hello" + "world"));// true

  // 通过反编译看源码,我们知道这里已经做好了处理。
  // System.out.println(s3 == "helloworld");
  // System.out.println(s3.equals("helloworld"));
 }
}



package cn.itcast_03;

import java.util.Scanner;

/*
 * 这时猜数字小游戏的代码
 */
public class GuessNumberGame {
 private GuessNumberGame() {
 }

 public static void start() {
  // 产生一个随机数
  int number = (int) (Math.random() * 100) + 1;

  while (true) {
   // 键盘录入数据
   Scanner sc = new Scanner(System.in);
   System.out.println("请输入你要猜的数据(1-100):");
   int guessNumber = sc.nextInt();

   // 判断
   if (guessNumber > number) {
    System.out.println("你猜的数据" + guessNumber + "大了");
   } else if (guessNumber < number) {
    System.out.println("你猜的数据" + guessNumber + "小了");
   } else {
    System.out.println("恭喜你,猜中了");
    break;
   }
  }
 }
}



package cn.itcast_03;

/*
 * String类的判断功能:
 * boolean equals(Object obj):比较字符串的内容是否相同,区分大小写
 * boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
 * boolean contains(String str):判断大字符串中是否包含小字符串
 * boolean startsWith(String str):判断字符串是否以某个指定的字符串开头
 * boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾
 * boolean isEmpty():判断字符串是否为空。
 *
 * 注意:
 *   字符串内容为空和字符串对象为空。
 *   String s = "";
 *   String s = null;
 */
public class StringDemo {
 public static void main(String[] args) {
  // 创建字符串对象
  String s1 = "helloworld";
  String s2 = "helloworld";
  String s3 = "HelloWorld";

  // boolean equals(Object obj):比较字符串的内容是否相同,区分大小写
  System.out.println("equals:" + s1.equals(s2));
  System.out.println("equals:" + s1.equals(s3));
  System.out.println("-----------------------");

  // boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
  System.out.println("equals:" + s1.equalsIgnoreCase(s2));
  System.out.println("equals:" + s1.equalsIgnoreCase(s3));
  System.out.println("-----------------------");

  // boolean contains(String str):判断大字符串中是否包含小字符串
  System.out.println("contains:" + s1.contains("hello"));
  System.out.println("contains:" + s1.contains("hw"));
  System.out.println("-----------------------");

  // boolean startsWith(String str):判断字符串是否以某个指定的字符串开头
  System.out.println("startsWith:" + s1.startsWith("h"));
  System.out.println("startsWith:" + s1.startsWith("hello"));
  System.out.println("startsWith:" + s1.startsWith("world"));
  System.out.println("-----------------------");

  // 练习:boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾这个自己玩

  // boolean isEmpty():判断字符串是否为空。
  System.out.println("isEmpty:" + s1.isEmpty());

  String s4 = "";
  String s5 = null;
  System.out.println("isEmpty:" + s4.isEmpty());
  // NullPointerException
  // s5对象都不存在,所以不能调用方法,空指针异常
  System.out.println("isEmpty:" + s5.isEmpty());
 }
}



package cn.itcast_03;

import java.util.Scanner;

/*
 * 模拟登录,给三次机会,并提示还有几次。
 *
 * 分析:
 *   A:定义用户名和密码。已存在的。
 *   B:键盘录入用户名和密码。
 *   C:比较用户名和密码。
 *    如果都相同,则登录成功
 *    如果有一个不同,则登录失败
 *   D:给三次机会,用循环改进,最好用for循环。
 */
public class StringTest {
 public static void main(String[] args) {
  // 定义用户名和密码。已存在的。
  String username = "admin";
  String password = "admin";

  // 给三次机会,用循环改进,最好用for循环。
  for (int x = 0; x < 3; x++) {
   // x=0,1,2
   // 键盘录入用户名和密码。
   Scanner sc = new Scanner(System.in);
   System.out.println("请输入用户名:");
   String name = sc.nextLine();
   System.out.println("请输入密码:");
   String pwd = sc.nextLine();

   // 比较用户名和密码。
   if (name.equals(username) && pwd.equals(password)) {
    // 如果都相同,则登录成功
    System.out.println("登录成功");
    break;
   } else {
    // 如果有一个不同,则登录失败
    // 2,1,0
    // 如果是第0次,应该换一种提示
    if ((2 - x) == 0) {
     System.out.println("帐号被锁定,请与班长联系");
    } else {
     System.out.println("登录失败,你还有" + (2 - x) + "次机会");
    }
   }
  }
 }
}



package cn.itcast_03;

import java.util.Scanner;

/*
 * 模拟登录,给三次机会,并提示还有几次。如果登录成功,就可以玩猜数字小游戏了。
 *
 * 分析:
 *   A:定义用户名和密码。已存在的。
 *   B:键盘录入用户名和密码。
 *   C:比较用户名和密码。
 *    如果都相同,则登录成功
 *    如果有一个不同,则登录失败
 *   D:给三次机会,用循环改进,最好用for循环。
 */
public class StringTest2 {
 public static void main(String[] args) {
  // 定义用户名和密码。已存在的。
  String username = "admin";
  String password = "admin";

  // 给三次机会,用循环改进,最好用for循环。
  for (int x = 0; x < 3; x++) {
   // x=0,1,2
   // 键盘录入用户名和密码。
   Scanner sc = new Scanner(System.in);
   System.out.println("请输入用户名:");
   String name = sc.nextLine();
   System.out.println("请输入密码:");
   String pwd = sc.nextLine();

   // 比较用户名和密码。
   if (name.equals(username) && pwd.equals(password)) {
    // 如果都相同,则登录成功
    System.out.println("登录成功,开始玩游戏");
    //猜数字游戏
    GuessNumberGame.start();
    break;
   } else {
    // 如果有一个不同,则登录失败
    // 2,1,0
    // 如果是第0次,应该换一种提示
    if ((2 - x) == 0) {
     System.out.println("帐号被锁定,请与班长联系");
    } else {
     System.out.println("登录失败,你还有" + (2 - x) + "次机会");
    }
   }
  }
 }
}



package cn.itcast_04;

/*
 * String类的获取功能
 * int length():获取字符串的长度。
 * char charAt(int index):获取指定索引位置的字符
 * int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。
 *   为什么这里是int类型,而不是char类型?
 *   原因是:'a'和97其实都可以代表'a'
 * int indexOf(String str):返回指定字符串在此字符串中第一次出现处的索引。
 * int indexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索引。
 * int indexOf(String str,int fromIndex):返回指定字符串在此字符串中从指定位置后第一次出现处的索引。
 * String substring(int start):从指定位置开始截取字符串,默认到末尾。
 * String substring(int start,int end):从指定位置开始到指定位置结束截取字符串。
 */
public class StringDemo {
 public static void main(String[] args) {
  // 定义一个字符串对象
  String s = "helloworld";

  // int length():获取字符串的长度。
  System.out.println("s.length:" + s.length());
  System.out.println("----------------------");

  // char charAt(int index):获取指定索引位置的字符
  System.out.println("charAt:" + s.charAt(7));
  System.out.println("----------------------");

  // int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。
  System.out.println("indexOf:" + s.indexOf('l'));
  System.out.println("----------------------");

  // int indexOf(String str):返回指定字符串在此字符串中第一次出现处的索引。
  System.out.println("indexOf:" + s.indexOf("owo"));
  System.out.println("----------------------");

  // int indexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索引。
  System.out.println("indexOf:" + s.indexOf('l', 4));
  System.out.println("indexOf:" + s.indexOf('k', 4)); // -1
  System.out.println("indexOf:" + s.indexOf('l', 40)); // -1
  System.out.println("----------------------");

  // 自己练习:int indexOf(String str,int
  // fromIndex):返回指定字符串在此字符串中从指定位置后第一次出现处的索引。

  // String substring(int start):从指定位置开始截取字符串,默认到末尾。包含start这个索引
  System.out.println("substring:" + s.substring(5));
  System.out.println("substring:" + s.substring(0));
  System.out.println("----------------------");

  // String substring(int start,int
  // end):从指定位置开始到指定位置结束截取字符串。包括start索引但是不包end索引
  System.out.println("substring:" + s.substring(3, 8));
  System.out.println("substring:" + s.substring(0, s.length()));
 }
}



package cn.itcast_04;

/*
 * 需求:遍历获取字符串中的每一个字符
 *
 * 分析:
 *   A:如何能够拿到每一个字符呢?
 *    char charAt(int index)
 *   B:我怎么知道字符到底有多少个呢?
 *    int length()
 */
public class StringTest {
 public static void main(String[] args) {
  // 定义字符串
  String s = "helloworld";

  // 原始版本
  // System.out.println(s.charAt(0));
  // System.out.println(s.charAt(1));
  // System.out.println(s.charAt(2));
  // System.out.println(s.charAt(3));
  // System.out.println(s.charAt(4));
  // System.out.println(s.charAt(5));
  // System.out.println(s.charAt(6));
  // System.out.println(s.charAt(7));
  // System.out.println(s.charAt(8));
  // System.out.println(s.charAt(9));

  // 只需要我们从0取到9
  // for (int x = 0; x < 10; x++) {
  // System.out.println(s.charAt(x));
  // }

  // 如果长度特别长,我不可能去数,所以我们要用长度功能
  for (int x = 0; x < s.length(); x++) {
   // char ch = s.charAt(x);
   // System.out.println(ch);
   // 仅仅是输出,我就直接输出了
   System.out.println(s.charAt(x));
  }
 }
}



package cn.itcast_04;

/*
 * 需求:统计一个字符串中大写字母字符,小写字母字符,数字字符出现的次数。(不考虑其他字符)
 * 举例:
 *   "Hello123World"
 * 结果:
 *   大写字符:2个
 *   小写字符:8个
 *   数字字符:3个
 *
 * 分析:
 *   前提:字符串要存在
 *   A:定义三个统计变量
 *    bigCount=0
 *    smallCount=0
 *    numberCount=0
 *   B:遍历字符串,得到每一个字符。
 *    length()和charAt()结合
 *   C:判断该字符到底是属于那种类型的
 *    大:bigCount++
 *    小:smallCount++
 *    数字:numberCount++
 *
 *    这道题目的难点就是如何判断某个字符是大的,还是小的,还是数字的。
 *    ASCII码表:
 *     0 48
 *     A 65
 *     a 97
 *    虽然,我们按照数字的这种比较是可以的,但是想多了,有比这还简单的
 *     char ch = s.charAt(x);
 *
 *     if(ch>='0' && ch<='9') numberCount++
 *     if(ch>='a' && ch<='z') smallCount++
 *     if(ch>='A' && ch<='Z') bigCount++
 *  D:输出结果。
 *
 * 练习:把给定字符串的方式,改进为键盘录入字符串的方式。
 */
public class StringTest2 {
 public static void main(String[] args) {
  //定义一个字符串
  String s = "Hello123World";
  
  //定义三个统计变量
  int bigCount = 0;
  int smallCount = 0;
  int numberCount = 0;
  
  //遍历字符串,得到每一个字符。
  for(int x=0; x<s.length(); x++){
   char ch = s.charAt(x);
   
   //判断该字符到底是属于那种类型的
   if(ch>='a' && ch<='z'){
    smallCount++;
   }else if(ch>='A' && ch<='Z'){
    bigCount++;
   }else if(ch>='0' && ch<='9'){
    numberCount++;
   }
  }
  
  //输出结果。
  System.out.println("大写字母"+bigCount+"个");
  System.out.println("小写字母"+smallCount+"个");
  System.out.println("数字"+numberCount+"个");
 }
}



package cn.itcast_05;

/*
 * String的转换功能:
 * byte[] getBytes():把字符串转换为字节数组。
 * char[] toCharArray():把字符串转换为字符数组。
 * static String valueOf(char[] chs):把字符数组转成字符串。
 * static String valueOf(int i):把int类型的数据转成字符串。
 *   注意:String类的valueOf方法可以把任意类型的数据转成字符串。
 * String toLowerCase():把字符串转成小写。
 * String toUpperCase():把字符串转成大写。
 * String concat(String str):把字符串拼接。
 */
public class StringDemo {
 public static void main(String[] args) {
  // 定义一个字符串对象
  String s = "JavaSE";

  // byte[] getBytes():把字符串转换为字节数组。
  byte[] bys = s.getBytes();
  for (int x = 0; x < bys.length; x++) {
   System.out.println(bys[x]);
  }
  System.out.println("----------------");

  // char[] toCharArray():把字符串转换为字符数组。
  char[] chs = s.toCharArray();
  for (int x = 0; x < chs.length; x++) {
   System.out.println(chs[x]);
  }
  System.out.println("----------------");

  // static String valueOf(char[] chs):把字符数组转成字符串。
  String ss = String.valueOf(chs);
  System.out.println(ss);
  System.out.println("----------------");

  // static String valueOf(int i):把int类型的数据转成字符串。
  int i = 100;
  String sss = String.valueOf(i);
  System.out.println(sss);
  System.out.println("----------------");

  // String toLowerCase():把字符串转成小写。
  System.out.println("toLowerCase:" + s.toLowerCase());
  System.out.println("s:" + s);
  // System.out.println("----------------");
  // String toUpperCase():把字符串转成大写。
  System.out.println("toUpperCase:" + s.toUpperCase());
  System.out.println("----------------");

  // String concat(String str):把字符串拼接。
  String s1 = "hello";
  String s2 = "world";
  String s3 = s1 + s2;
  String s4 = s1.concat(s2);
  System.out.println("s3:"+s3);
  System.out.println("s4:"+s4);
 }
}



package cn.itcast_05;

/*
 * 需求:把一个字符串的首字母转成大写,其余为小写。(只考虑英文大小写字母字符)
 * 举例:
 *   helloWORLD
 * 结果:
 *   Helloworld
 *
 * 分析:
 *   A:先获取第一个字符
 *   B:获取除了第一个字符以外的字符
 *   C:把A转成大写
 *   D:把B转成小写
 *   E:C拼接D
 */
public class StringTest {
 public static void main(String[] args) {
  // 定义一个字符串
  String s = "helloWORLD";

  // 先获取第一个字符
  String s1 = s.substring(0, 1);
  // 获取除了第一个字符以外的字符
  String s2 = s.substring(1);
  // 把A转成大写
  String s3 = s1.toUpperCase();
  // 把B转成小写
  String s4 = s2.toLowerCase();
  // C拼接D
  String s5 = s3.concat(s4);
  System.out.println(s5);

  // 优化后的代码
  // 链式编程
  String result = s.substring(0, 1).toUpperCase()
    .concat(s.substring(1).toLowerCase());
  System.out.println(result);
 }
}



package cn.itcast_06;

/*
 * String类的其他功能:
 *
 * 替换功能:
 * String replace(char old,char new)
 * String replace(String old,String new)
 *
 * 去除字符串两空格 
 * String trim()
 *
 * 按字典顺序比较两个字符串 
 * int compareTo(String str)
 * int compareToIgnoreCase(String str)
 */
public class StringDemo {
 public static void main(String[] args) {
  // 替换功能
  String s1 = "helloworld";
  String s2 = s1.replace('l', 'k');
  String s3 = s1.replace("owo", "ak47");
  System.out.println("s1:" + s1);
  System.out.println("s2:" + s2);
  System.out.println("s3:" + s3);
  System.out.println("---------------");

  // 去除字符串两空格
  String s4 = " hello world  ";
  String s5 = s4.trim();
  System.out.println("s4:" + s4 + "---");
  System.out.println("s5:" + s5 + "---");

  // 按字典顺序比较两个字符串
  String s6 = "hello";
  String s7 = "hello";
  String s8 = "abc";
  String s9 = "xyz";
  System.out.println(s6.compareTo(s7));// 0
  System.out.println(s6.compareTo(s8));// 7
  System.out.println(s6.compareTo(s9));// -16
 }
}



package cn.itcast_06;

/*
 * 如果我们看到问题了,看怎么办呢?
 * 看源码。
 */
public class StringTest {
 public static void main(String[] args) {
  String s1 = "hello";
  String s2 = "hel";
  System.out.println(s1.compareTo(s2)); // 2
 }
}



  private final char value[];
 
    字符串会自动转换为一个字符数组。
 
  public int compareTo(String anotherString) {
    //this -- s1 -- "hello"
    //anotherString -- s2 -- "hel"
 
        int len1 = value.length; //this.value.length--s1.toCharArray().length--5
        int len2 = anotherString.value.length;//s2.value.length -- s2.toCharArray().length--3
        int lim = Math.min(len1, len2); //Math.min(5,3); -- lim=3;
        char v1[] = value; //s1.toCharArray()
        char v2[] = anotherString.value;
       
        //char v1[] = {'h','e','l','l','o'};
        //char v2[] = {'h','e','l'};

        int k = 0;
        while (k < lim) {
            char c1 = v1[k]; //c1='h','e','l'
            char c2 = v2[k]; //c2='h','e','l'
            if (c1 != c2) {
                return c1 - c2;
            }
            k++;
        }
        return len1 - len2; //5-3=2;
   }
  
   String s1 = "hello";
   String s2 = "hel";
   System.out.println(s1.compareTo(s2)); // 2



package cn.itcast_07;

/*
 * 需求:把数组中的数据按照指定个格式拼接成一个字符串
 * 举例:
 *   int[] arr = {1,2,3}; 
 * 输出结果:
 *  "[1, 2, 3]"
 * 分析:
 *   A:定义一个字符串对象,只不过内容为空
 *   B:先把字符串拼接一个"["
 *   C:遍历int数组,得到每一个元素
 *   D:先判断该元素是否为最后一个
 *    是:就直接拼接元素和"]"
 *    不是:就拼接元素和逗号以及空格
 *   E:输出拼接后的字符串
 */
public class StringTest {
 public static void main(String[] args) {
  // 前提是数组已经存在
  int[] arr = { 1, 2, 3 };

  // 定义一个字符串对象,只不过内容为空
  String s = "";

  // 先把字符串拼接一个"["
  s += "[";

  // 遍历int数组,得到每一个元素
  for (int x = 0; x < arr.length; x++) {
   // 先判断该元素是否为最后一个
   if (x == arr.length - 1) {
    // 就直接拼接元素和"]"
    s += arr[x];
    s += "]";
   } else {
    // 就拼接元素和逗号以及空格
    s += arr[x];
    s += ", ";
   }
  }

  // 输出拼接后的字符串
  System.out.println("最终的字符串是:" + s);
 }
}



package cn.itcast_07;

/*
 * 需求:把数组中的数据按照指定个格式拼接成一个字符串
 * 举例:
 *   int[] arr = {1,2,3}; 
 * 输出结果:
 *  "[1, 2, 3]"
 * 分析:
 *   A:定义一个字符串对象,只不过内容为空
 *   B:先把字符串拼接一个"["
 *   C:遍历int数组,得到每一个元素
 *   D:先判断该元素是否为最后一个
 *    是:就直接拼接元素和"]"
 *    不是:就拼接元素和逗号以及空格
 *   E:输出拼接后的字符串
 *
 * 把代码用功能实现。
 */
public class StringTest2 {
 public static void main(String[] args) {
  // 前提是数组已经存在
  int[] arr = { 1, 2, 3 };

  // 写一个功能,实现结果
  String result = arrayToString(arr);
  System.out.println("最终结果是:" + result);
 }

 /*
  * 两个明确: 返回值类型:String 参数列表:int[] arr
  */
 public static String arrayToString(int[] arr) {
  // 定义一个字符串
  String s = "";

  // 先把字符串拼接一个"["
  s += "[";

  // 遍历int数组,得到每一个元素
  for (int x = 0; x < arr.length; x++) {
   // 先判断该元素是否为最后一个
   if (x == arr.length - 1) {
    // 就直接拼接元素和"]"
    s += arr[x];
    s += "]";
   } else {
    // 就拼接元素和逗号以及空格
    s += arr[x];
    s += ", ";
   }
  }

  return s;
 }
}



package cn.itcast_07;

import java.util.Scanner;

/*
 * 字符串反转
 * 举例:键盘录入”abc”  
 * 输出结果:”cba”
 *
 * 分析:
 *   A:键盘录入一个字符串
 *   B:定义一个新字符串
 *   C:倒着遍历字符串,得到每一个字符
 *    a:length()和charAt()结合
 *    b:把字符串转成字符数组
 *   D:用新字符串把每一个字符拼接起来
 *   E:输出新串
 */
public class StringTest3 {
 public static void main(String[] args) {
  // 键盘录入一个字符串
  Scanner sc = new Scanner(System.in);
  System.out.println("请输入一个字符串:");
  String line = sc.nextLine();

  /*
  // 定义一个新字符串
  String result = "";

  // 把字符串转成字符数组
  char[] chs = line.toCharArray();

  // 倒着遍历字符串,得到每一个字符
  for (int x = chs.length - 1; x >= 0; x--) {
   // 用新字符串把每一个字符拼接起来
   result += chs[x];
  }

  // 输出新串
  System.out.println("反转后的结果是:" + result);
  */

  // 改进为功能实现
  String s = myReverse(line);
  System.out.println("实现功能后的结果是:" + s);
 }

 /*
  * 两个明确: 返回值类型:String 参数列表:String
  */
 public static String myReverse(String s) {
  // 定义一个新字符串
  String result = "";

  // 把字符串转成字符数组
  char[] chs = s.toCharArray();

  // 倒着遍历字符串,得到每一个字符
  for (int x = chs.length - 1; x >= 0; x--) {
   // 用新字符串把每一个字符拼接起来
   result += chs[x];
  }
  return result;
 }
}



package cn.itcast_07;

/*
 * 统计大串中小串出现的次数
 * 举例:
 *   在字符串"woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun"
 * 结果:
 *   java出现了5次
 *
 * 分析:
 *   前提:是已经知道了大串和小串。
 *
 *   A:定义一个统计变量,初始化值是0
 *   B:先在大串中查找一次小串第一次出现的位置
 *    a:索引是-1,说明不存在了,就返回统计变量
 *    b:索引不是-1,说明存在,统计变量++
 *   C:把刚才的索引+小串的长度作为开始位置截取上一次的大串,返回一个新的字符串,并把该字符串的值重新赋值给大串
 *   D:回到B
 */
public class StringTest4 {
 public static void main(String[] args) {
  // 定义大串
  String maxString = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun";
  // 定义小串
  String minString = "java";

  // 写功能实现
  int count = getCount(maxString, minString);
  System.out.println("Java在大串中出现了:" + count + "次");
 }

 /*
  * 两个明确: 返回值类型:int 参数列表:两个字符串
  */
 public static int getCount(String maxString, String minString) {
  // 定义一个统计变量,初始化值是0
  int count = 0;

  // 先在大串中查找一次小串第一次出现的位置
  int index = maxString.indexOf(minString);

  // 索引不是-1,说明存在,统计变量++
  while (index != -1) {
   count++;
   // 把刚才的索引+小串的长度作为开始位置截取上一次的大串,返回一个新的字符串,并把该字符串的值重新赋值给大串
   int startIndex = index + minString.length();
   maxString = maxString.substring(startIndex);
   // 继续查
   index = maxString.indexOf(minString);
  }

  return count;
 }
}



package cn.itcast_07;

/*
 * 统计大串中小串出现的次数
 * 举例:
 *   在字符串"woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun"
 * 结果:
 *   java出现了5次
 *
 * 分析:
 *   前提:是已经知道了大串和小串。
 *
 *   A:定义一个统计变量,初始化值是0
 *   B:先在大串中查找一次小串第一次出现的位置
 *    a:索引是-1,说明不存在了,就返回统计变量
 *    b:索引不是-1,说明存在,统计变量++
 *   C:把刚才的索引+小串的长度作为开始位置截取上一次的大串,返回一个新的字符串,并把该字符串的值重新赋值给大串
 *   D:回到B
 */
public class StringTest5 {
 public static void main(String[] args) {
  // 定义大串
  String maxString = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun";
  // 定义小串
  String minString = "java";

  // 写功能实现
  int count = getCount(maxString, minString);
  System.out.println("Java在大串中出现了:" + count + "次");
 }

 /*
  * 两个明确: 返回值类型:int 参数列表:两个字符串
  */
 public static int getCount(String maxString, String minString) {
  // 定义一个统计变量,初始化值是0
  int count = 0;

  /*
  // 先在大串中查找一次小串第一次出现的位置
  int index = maxString.indexOf(minString);
  // 索引不是-1,说明存在,统计变量++
  while (index != -1) {
   count++;
   // 把刚才的索引+小串的长度作为开始位置截取上一次的大串,返回一个新的字符串,并把该字符串的值重新赋值给大串
   // int startIndex = index + minString.length();
   // maxString = maxString.substring(startIndex);
   maxString = maxString.substring(index + minString.length());
   // 继续查
   index = maxString.indexOf(minString);
  }
  */
  
  int index;
  //先查,赋值,判断
  while((index=maxString.indexOf(minString))!=-1){
   count++;
   maxString = maxString.substring(index + minString.length());
  }

  return count;
 }
}



                                    图一 :String的特点一旦被赋值就不能改变

 image.png

                                   图二:在大串中查找小串出现的次数思路图解:

image.png



5:Array类



package cn.itcast_01;

/*
 * 数组排序之冒泡排序:
 *   相邻元素两两比较,大的往后放,第一次完毕,最大值出现在了最大索引处
 */
public class ArrayDemo {
 public static void main(String[] args) {
  // 定义一个数组
  int[] arr = { 24, 69, 80, 57, 13 };
  System.out.println("排序前:");
  printArray(arr);

  /*
  // 第一次比较
  // arr.length - 1是为了防止数据越界
  // arr.length - 1 - 0是为了减少比较的次数
  for (int x = 0; x < arr.length - 1 - 0; x++) {
   if (arr[x] > arr[x + 1]) {
    int temp = arr[x];
    arr[x] = arr[x + 1];
    arr[x + 1] = temp;
   }
  }
  System.out.println("第一次比较后:");
  printArray(arr);

  // 第二次比较
  // arr.length - 1是为了防止数据越界
  // arr.length - 1 - 1是为了减少比较的次数
  for (int x = 0; x < arr.length - 1 - 1; x++) {
   if (arr[x] > arr[x + 1]) {
    int temp = arr[x];
    arr[x] = arr[x + 1];
    arr[x + 1] = temp;
   }
  }
  System.out.println("第二次比较后:");
  printArray(arr);

  // 第三次比较
  // arr.length - 1是为了防止数据越界
  // arr.length - 1 - 2是为了减少比较的次数
  for (int x = 0; x < arr.length - 1 - 2; x++) {
   if (arr[x] > arr[x + 1]) {
    int temp = arr[x];
    arr[x] = arr[x + 1];
    arr[x + 1] = temp;
   }
  }
  System.out.println("第三次比较后:");
  printArray(arr);

  // 第四次比较
  // arr.length - 1是为了防止数据越界
  // arr.length - 1 - 3是为了减少比较的次数
  for (int x = 0; x < arr.length - 1 - 3; x++) {
   if (arr[x] > arr[x + 1]) {
    int temp = arr[x];
    arr[x] = arr[x + 1];
    arr[x + 1] = temp;
   }
  }
  System.out.println("第四次比较后:");
  printArray(arr);
  */

  // 既然听懂了,那么上面的代码就是排序代码
  // 而上面的代码重复度太高了,所以用循环改进
  // for (int y = 0; y < 4; y++) {
  // for (int x = 0; x < arr.length - 1 - y; x++) {
  // if (arr[x] > arr[x + 1]) {
  // int temp = arr[x];
  // arr[x] = arr[x + 1];
  // arr[x + 1] = temp;
  // }
  // }
  // }

  /*
  // 由于我们知道比较的次数是数组长度-1次,所以改进最终版程序
  for (int x = 0; x < arr.length - 1; x++) {
   for (int y = 0; y < arr.length - 1 - x; y++) {
    if (arr[y] > arr[y + 1]) {
     int temp = arr[y];
     arr[y] = arr[y + 1];
     arr[y + 1] = temp;
    }
   }
  }
  System.out.println("排序后:");
  printArray(arr);
  */
  
  //由于我可能有多个数组要排序,所以我要写成方法
  bubbleSort(arr);
  System.out.println("排序后:");
  printArray(arr);
 }
 
 //冒泡排序代码
 public static void bubbleSort(int[] arr){
  for (int x = 0; x < arr.length - 1; x++) {
   for (int y = 0; y < arr.length - 1 - x; y++) {
    if (arr[y] > arr[y + 1]) {
     int temp = arr[y];
     arr[y] = arr[y + 1];
     arr[y + 1] = temp;
    }
   }
  }
 }

 // 遍历功能
 public static void printArray(int[] arr) {
  System.out.print("[");
  for (int x = 0; x < arr.length; x++) {
   if (x == arr.length - 1) {
    System.out.print(arr[x]);
   } else {
    System.out.print(arr[x] + ", ");
   }
  }
  System.out.println("]");
 }
}



                   图二: 数组高级二分查找原理图解

image.png

 

                            图三:数组高级选择排序原理图解

image.png

                        图四 数组高级冒泡排序原理图解

;image.png

package cn.itcast_02;

/*
 * 数组排序之选择排序:
 *   从0索引开始,依次和后面元素比较,小的往前放,第一次完毕,最小值出现在了最小索引处
 */
public class ArrayDemo {
 public static void main(String[] args) {
  // 定义一个数组
  int[] arr = { 24, 69, 80, 57, 13 };
  System.out.println("排序前:");
  printArray(arr);

  /*
  // 第一次
  int x = 0;
  for (int y = x + 1; y < arr.length; y++) {
   if (arr[y] < arr[x]) {
    int temp = arr[x];
    arr[x] = arr[y];
    arr[y] = temp;
   }
  }
  System.out.println("第一次比较后:");
  printArray(arr);

  // 第二次
  x = 1;
  for (int y = x + 1; y < arr.length; y++) {
   if (arr[y] < arr[x]) {
    int temp = arr[x];
    arr[x] = arr[y];
    arr[y] = temp;
   }
  }
  System.out.println("第二次比较后:");
  printArray(arr);

  // 第三次
  x = 2;
  for (int y = x + 1; y < arr.length; y++) {
   if (arr[y] < arr[x]) {
    int temp = arr[x];
    arr[x] = arr[y];
    arr[y] = temp;
   }
  }
  System.out.println("第三次比较后:");
  printArray(arr);

  // 第四次
  x = 3;
  for (int y = x + 1; y < arr.length; y++) {
   if (arr[y] < arr[x]) {
    int temp = arr[x];
    arr[x] = arr[y];
    arr[y] = temp;
   }
  }
  System.out.println("第四次比较后:");
  printArray(arr);
  */
  
  /*
  //通过观察发现代码的重复度太高,所以用循环改进
  for(int x=0; x<arr.length-1; x++){
   for(int y=x+1; y<arr.length; y++){
    if(arr[y] <arr[x]){
     int temp = arr[x];
     arr[x] = arr[y];
      arr[y] = temp;
    }
   }
  }
  System.out.println("排序后:");
  printArray(arr);
  */
  
  //用方法改进
  selectSort(arr);
  System.out.println("排序后:");
  printArray(arr);

 }
 
 public static void selectSort(int[] arr){
  for(int x=0; x<arr.length-1; x++){
   for(int y=x+1; y<arr.length; y++){
    if(arr[y] <arr[x]){
     int temp = arr[x];
     arr[x] = arr[y];
      arr[y] = temp;
    }
   }
  }
 }

 // 遍历功能
 public static void printArray(int[] arr) {
  System.out.print("[");
  for (int x = 0; x < arr.length; x++) {
   if (x == arr.length - 1) {
    System.out.print(arr[x]);
   } else {
    System.out.print(arr[x] + ", ");
   }
  }
  System.out.println("]");
 }
}



package cn.itcast_03;

/*
 * 把字符串中的字符进行排序。
 *   举例:"dacgebf"
 *   结果:"abcdefg"
 *
 * 分析:
 *   A:定义一个字符串
 *   B:把字符串转换为字符数组
 *   C:把字符数组进行排序
 *   D:把排序后的字符数组转成字符串
 *   E:输出最后的字符串
 */
public class ArrayTest {
 public static void main(String[] args) {
  // 定义一个字符串
  String s = "dacgebf";

  // 把字符串转换为字符数组
  char[] chs = s.toCharArray();

  // 把字符数组进行排序
  bubbleSort(chs);

  //把排序后的字符数组转成字符串
  String result = String.valueOf(chs);
  
  //输出最后的字符串
  System.out.println("result:"+result);
 }

 // 冒泡排序
 public static void bubbleSort(char[] chs) {
  for (int x = 0; x < chs.length - 1; x++) {
   for (int y = 0; y < chs.length - 1 - x; y++) {
    if (chs[y] > chs[y + 1]) {
     char temp = chs[y];
     chs[y] = chs[y + 1];
     chs[y + 1] = temp;
    }
   }
  }
 }
}



package cn.itcast_04;

/*
 * 查找:
 *   基本查找:数组元素无序(从头找到尾)
 *   二分查找(折半查找):数组元素有序
 *
 * 分析:
 *   A:定义最大索引,最小索引
 *   B:计算出中间索引
 *   C:拿中间索引的值和要查找的值进行比较
 *    相等:就返回当前的中间索引
 *    不相等:
 *     大 左边找
 *     小 右边找
 *   D:重新计算出中间索引
 *    大 左边找
 *     max = mid - 1;
 *    小 右边找
 *     min = mid + 1;
 *   E:回到B
 */
public class ArrayDemo {
 public static void main(String[] args) {
  //定义一个数组
  int[] arr = {11,22,33,44,55,66,77};
  
  //写功能实现
  int index = getIndex(arr, 33);
  System.out.println("index:"+index);
  
  //假如这个元素不存在后有什么现象呢?
  index = getIndex(arr, 333);
  System.out.println("index:"+index);
 }
 
 /*
  * 两个明确:
  * 返回值类型:int
  * 参数列表:int[] arr,int value
  */
 public static int getIndex(int[] arr,int value){
  //定义最大索引,最小索引
  int max = arr.length -1;
  int min = 0;
  
  //计算出中间索引
  int mid = (max +min)/2;
  
  //拿中间索引的值和要查找的值进行比较
  while(arr[mid] != value){
   if(arr[mid]>value){
    max = mid - 1;
   }else if(arr[mid]<value){
    min = mid + 1;
   }
   
   //加入判断
   if(min > max){
    return -1;
   }
   
   mid = (max +min)/2;
  }
  
  return mid;
 }
}



package cn.itcast_05;

import java.util.Arrays;

/*
 * Arrays:针对数组进行操作的工具类。比如说排序和查找。
 * 1:public static String toString(int[] a) 把数组转成字符串
 * 2:public static void sort(int[] a) 对数组进行排序
 * 3:public static int binarySearch(int[] a,int key) 二分查找
 */
public class ArraysDemo {
 public static void main(String[] args) {
  // 定义一个数组
  int[] arr = { 24, 69, 80, 57, 13 };

  // public static String toString(int[] a) 把数组转成字符串
  System.out.println("排序前:" + Arrays.toString(arr));

  // public static void sort(int[] a) 对数组进行排序
  Arrays.sort(arr);
  System.out.println("排序后:" + Arrays.toString(arr));

  // [13, 24, 57, 69, 80]
  // public static int binarySearch(int[] a,int key) 二分查找
  System.out.println("binarySearch:" + Arrays.binarySearch(arr, 57));
  System.out.println("binarySearch:" + Arrays.binarySearch(arr, 577));
 }
}



public static String toString(int[] a)
public static void sort(int[] a) 底层是快速排序,知道就可以了。有空看,
public static int binarySearch(int[] a,int key)

开发原则:
 只要是对象,我们就要判断该对象是否为null。

int[] arr = { 24, 69, 80, 57, 13 };
System.out.println("排序前:" + Arrays.toString(arr));

public static String toString(int[] a) {
 //a -- arr -- { 24, 69, 80, 57, 13 }

    if (a == null)
        return "null"; //说明数组对象不存在
    int iMax = a.length - 1; //iMax=4;
    if (iMax == -1)
        return "[]"; //说明数组存在,但是没有元素。

    StringBuilder b = new StringBuilder();
    b.append('['); //"["
    for (int i = 0; ; i++) {
        b.append(a[i]); //"[24, 69, 80, 57, 13"
        if (i == iMax)
         //"[24, 69, 80, 57, 13]"
            return b.append(']').toString();
        b.append(", "); //"[24, 69, 80, 57, "
    }
}
-----------------------------------------------------

int[] arr = {13, 24, 57, 69, 80};
System.out.println("binarySearch:" + Arrays.binarySearch(arr, 577));

public static int binarySearch(int[] a, int key) {
 //a -- arr -- {13, 24, 57, 69, 80}
 //key -- 577
    return binarySearch0(a, 0, a.length, key);
}

private static int binarySearch0(int[] a, int fromIndex, int toIndex,
                                 int key) {
    //a -- arr --  {13, 24, 57, 69, 80}
    //fromIndex -- 0
    //toIndex -- 5
    //key -- 577                          
                                
                                
    int low = fromIndex; //low=0
    int high = toIndex - 1; //high=4

    while (low <= high) {
        int mid = (low + high) >>> 1; //mid=2,mid=3,mid=4
        int midVal = a[mid]; //midVal=57,midVal=69,midVal=80

        if (midVal < key)
            low = mid + 1; //low=3,low=4,low=5
        else if (midVal > key)
            high = mid - 1;
        else
            return mid; // key found
    }
    return -(low + 1);  // key not found.
}



6:Character

package cn.itcast_01;

/*
 * Character 类在对象中包装一个基本类型 char 的值
 * 此外,该类提供了几种方法,以确定字符的类别(小写字母,数字,等等),并将字符从大写转换成小写,反之亦然
 *
 * 构造方法:
 *   Character(char value)
 */
public class CharacterDemo {
 public static void main(String[] args) {
  // 创建对象
  // Character ch = new Character((char) 97);
  Character ch = new Character('a');
  System.out.println("ch:" + ch);
 }
}



package cn.itcast_02;

/*
 * public static boolean isUpperCase(char ch):判断给定的字符是否是大写字符
 * public static boolean isLowerCase(char ch):判断给定的字符是否是小写字符
 * public static boolean isDigit(char ch):判断给定的字符是否是数字字符
 * public static char toUpperCase(char ch):把给定的字符转换为大写字符
 * public static char toLowerCase(char ch):把给定的字符转换为小写字符
 */
public class CharacterDemo {
 public static void main(String[] args) {
  // public static boolean isUpperCase(char ch):判断给定的字符是否是大写字符
  System.out.println("isUpperCase:" + Character.isUpperCase('A'));
  System.out.println("isUpperCase:" + Character.isUpperCase('a'));
  System.out.println("isUpperCase:" + Character.isUpperCase('0'));
  System.out.println("-----------------------------------------");
  // public static boolean isLowerCase(char ch):判断给定的字符是否是小写字符
  System.out.println("isLowerCase:" + Character.isLowerCase('A'));
  System.out.println("isLowerCase:" + Character.isLowerCase('a'));
  System.out.println("isLowerCase:" + Character.isLowerCase('0'));
  System.out.println("-----------------------------------------");
  // public static boolean isDigit(char ch):判断给定的字符是否是数字字符
  System.out.println("isDigit:" + Character.isDigit('A'));
  System.out.println("isDigit:" + Character.isDigit('a'));
  System.out.println("isDigit:" + Character.isDigit('0'));
  System.out.println("-----------------------------------------");
  // public static char toUpperCase(char ch):把给定的字符转换为大写字符
  System.out.println("toUpperCase:" + Character.toUpperCase('A'));
  System.out.println("toUpperCase:" + Character.toUpperCase('a'));
  System.out.println("-----------------------------------------");
  // public static char toLowerCase(char ch):把给定的字符转换为小写字符
  System.out.println("toLowerCase:" + Character.toLowerCase('A'));
  System.out.println("toLowerCase:" + Character.toLowerCase('a'));
 }
}



package cn.itcast_03;

import java.util.Scanner;

/*
 * 统计一个字符串中大写字母字符,小写字母字符,数字字符出现的次数。(不考虑其他字符)
 *
 * 分析:
 *   A:定义三个统计变量。
 *    int bigCont=0;
 *    int smalCount=0;
 *    int numberCount=0;
 *   B:键盘录入一个字符串。
 *   C:把字符串转换为字符数组。
 *   D:遍历字符数组获取到每一个字符
 *   E:判断该字符是
 *    大写 bigCount++;
 *    小写 smalCount++;
 *    数字 numberCount++;
 *   F:输出结果即可
 */
public class CharacterTest {
 public static void main(String[] args) {
  // 定义三个统计变量。
  int bigCount = 0;
  int smallCount = 0;
  int numberCount = 0;

  // 键盘录入一个字符串。
  Scanner sc = new Scanner(System.in);
  System.out.println("请输入一个字符串:");
  String line = sc.nextLine();

  // 把字符串转换为字符数组。
  char[] chs = line.toCharArray();

  // 历字符数组获取到每一个字符
  for (int x = 0; x < chs.length; x++) {
   char ch = chs[x];

   // 判断该字符
   if (Character.isUpperCase(ch)) {
    bigCount++;
   } else if (Character.isLowerCase(ch)) {
    smallCount++;
   } else if (Character.isDigit(ch)) {
    numberCount++;
   }
  }

  // 输出结果即可
  System.out.println("大写字母:" + bigCount + "个");
  System.out.println("小写字母:" + smallCount + "个");
  System.out.println("数字字符:" + numberCount + "个");
 }
}



7:integer

package cn.itcast_01;

/*
 * 需求1:我要求大家把100这个数据的二进制,八进制,十六进制计算出来
 * 需求2:我要求大家判断一个数据是否是int范围内的。
 *   首先你的知道int的范围是多大?
 *
 * 为了对基本数据类型进行更多的操作,更方便的操作,Java就针对每一种基本数据类型提供了对应的类类型。包装类类型。
 * byte    Byte
 * short   Short
 * int    Integer
 * long    Long
 * float   Float
 * double   Double
 * char    Character
 * boolean   Boolean
 *
 * 用于基本数据类型与字符串之间的转换。
 */
public class IntegerDemo {
 public static void main(String[] args) {
  // 不麻烦的就来了
  // public static String toBinaryString(int i)
  System.out.println(Integer.toBinaryString(100));
  // public static String toOctalString(int i)
  System.out.println(Integer.toOctalString(100));
  // public static String toHexString(int i)
  System.out.println(Integer.toHexString(100));

  // public static final int MAX_VALUE
  System.out.println(Integer.MAX_VALUE);
  // public static final int MIN_VALUE
  System.out.println(Integer.MIN_VALUE);
 }
}



package cn.itcast_02;

/*
 * Integer的构造方法:
 * public Integer(int value)
 * public Integer(String s)
 *   注意:这个字符串必须是由数字字符组成
 */
public class IntegerDemo {
 public static void main(String[] args) {
  // 方式1
  int i = 100;
  Integer ii = new Integer(i);
  System.out.println("ii:" + ii);

  // 方式2
  String s = "100";
  // NumberFormatException
  // String s = "abc";
  Integer iii = new Integer(s);
  System.out.println("iii:" + iii);
 }
}



package cn.itcast_03;

/*
 * int类型和String类型的相互转换
 *
 * int -- String
 *   String.valueOf(number)
 *
 * String -- int
 *   Integer.parseInt(s)
 */
public class IntegerDemo {
 public static void main(String[] args) {
  // int -- String
  int number = 100;
  // 方式1
  String s1 = "" + number;
  System.out.println("s1:" + s1);
  // 方式2
  String s2 = String.valueOf(number);
  System.out.println("s2:" + s2);
  // 方式3
  // int -- Integer -- String
  Integer i = new Integer(number);
  String s3 = i.toString();
  System.out.println("s3:" + s3);
  // 方式4
  // public static String toString(int i)
  String s4 = Integer.toString(number);
  System.out.println("s4:" + s4);
  System.out.println("-----------------");

  // String -- int
  String s = "100";
  // 方式1
  // String -- Integer -- int
  Integer ii = new Integer(s);
  // public int intValue()
  int x = ii.intValue();
  System.out.println("x:" + x);
  //方式2
  //public static int parseInt(String s)
  int y = Integer.parseInt(s);
  System.out.println("y:"+y);
 }
}



package cn.itcast_04;

/*
 * 常用的基本进制转换
 * public static String toBinaryString(int i)
 * public static String toOctalString(int i)
 * public static String toHexString(int i)
 *
 * 十进制到其他进制
 * public static String toString(int i,int radix)
 * 由这个我们也看到了进制的范围:2-36
 * 为什么呢?0,...9,a...z
 *
 * 其他进制到十进制
 * public static int parseInt(String s,int radix)
 */
public class IntegerDemo {
 public static void main(String[] args) {
  // 十进制到二进制,八进制,十六进制
  System.out.println(Integer.toBinaryString(100));
  System.out.println(Integer.toOctalString(100));
  System.out.println(Integer.toHexString(100));
  System.out.println("-------------------------");

  // 十进制到其他进制
  System.out.println(Integer.toString(100, 10));
  System.out.println(Integer.toString(100, 2));
  System.out.println(Integer.toString(100, 8));
  System.out.println(Integer.toString(100, 16));
  System.out.println(Integer.toString(100, 5));
  System.out.println(Integer.toString(100, 7));
  System.out.println(Integer.toString(100, -7));
  System.out.println(Integer.toString(100, 70));
  System.out.println(Integer.toString(100, 1));
  System.out.println(Integer.toString(100, 17));
  System.out.println(Integer.toString(100, 32));
  System.out.println(Integer.toString(100, 37));
  System.out.println(Integer.toString(100, 36));
  System.out.println("-------------------------");
  
  //其他进制到十进制
  System.out.println(Integer.parseInt("100", 10));
  System.out.println(Integer.parseInt("100", 2));
  System.out.println(Integer.parseInt("100", 8));
  System.out.println(Integer.parseInt("100", 16));
  System.out.println(Integer.parseInt("100", 23));
  //NumberFormatException
  //System.out.println(Integer.parseInt("123", 2));
 }
}



package cn.itcast_05;

/*
 * JDK5的新特性
 * 自动装箱:把基本类型转换为包装类类型
 * 自动拆箱:把包装类类型转换为基本类型
 *
 * 注意一个小问题:
 *   在使用时,Integer  x = null;代码就会出现NullPointerException。
 *   建议先判断是否为null,然后再使用。
 */
public class IntegerDemo {
 public static void main(String[] args) {
  // 定义了一个int类型的包装类类型变量i
  // Integer i = new Integer(100);
  Integer ii = 100;
  ii += 200;
  System.out.println("ii:" + ii);

  // 通过反编译后的代码
  // Integer ii = Integer.valueOf(100); //自动装箱
  // ii = Integer.valueOf(ii.intValue() + 200); //自动拆箱,再自动装箱
  // System.out.println((new StringBuilder("ii:")).append(ii).toString());

  Integer iii = null;
  // NullPointerException
  if (iii != null) {
   iii += 1000;
   System.out.println(iii);
  }
 }
}



package cn.itcast_06;

/*
 * 看程序写结果
 *
 * 注意:Integer的数据直接赋值,如果在-128到127之间,会直接从缓冲池里获取数据
 */
public class IntegerDemo {
 public static void main(String[] args) {
  Integer i1 = new Integer(127);
  Integer i2 = new Integer(127);
  System.out.println(i1 == i2);
  System.out.println(i1.equals(i2));
  System.out.println("-----------");

  Integer i3 = new Integer(128);
  Integer i4 = new Integer(128);
  System.out.println(i3 == i4);
  System.out.println(i3.equals(i4));
  System.out.println("-----------");

  Integer i5 = 128;
  Integer i6 = 128;
  System.out.println(i5 == i6);
  System.out.println(i5.equals(i6));
  System.out.println("-----------");

  Integer i7 = 127;
  Integer i8 = 127;
  System.out.println(i7 == i8);
  System.out.println(i7.equals(i8));

  // 通过查看源码,我们就知道了,针对-128到127之间的数据,做了一个数据缓冲池,如果数据是该范围内的,每次并不创建新的空间
  // Integer ii = Integer.valueOf(127);
 }
}



8:StringBuffer类

package cn.itcast_01;

/*
 * 线程安全(多线程讲解)
 * 安全 -- 同步 -- 数据是安全的
 * 不安全 -- 不同步 -- 效率高一些
 * 安全和效率问题是永远困扰我们的问题。
 * 安全:医院的网站,银行网站
 * 效率:新闻网站,论坛之类的
 *
 * StringBuffer:
 *   线程安全的可变字符串。
 *
 * StringBuffer和String的区别?
 * 前者长度和内容可变,后者不可变。
 * 如果使用前者做字符串的拼接,不会浪费太多的资源。
 *
 * StringBuffer的构造方法:
 *   public StringBuffer():无参构造方法
 *  public StringBuffer(int capacity):指定容量的字符串缓冲区对象
 *  public StringBuffer(String str):指定字符串内容的字符串缓冲区对象
 *
 * StringBuffer的方法:
 *  public int capacity():返回当前容量。 理论值
 *  public int length():返回长度(字符数)。 实际值
 */
public class StringBufferDemo {
 public static void main(String[] args) {
  // public StringBuffer():无参构造方法
  StringBuffer sb = new StringBuffer();
  System.out.println("sb:" + sb);
  System.out.println("sb.capacity():" + sb.capacity());
  System.out.println("sb.length():" + sb.length());
  System.out.println("--------------------------");

  // public StringBuffer(int capacity):指定容量的字符串缓冲区对象
  StringBuffer sb2 = new StringBuffer(50);
  System.out.println("sb2:" + sb2);
  System.out.println("sb2.capacity():" + sb2.capacity());
  System.out.println("sb2.length():" + sb2.length());
  System.out.println("--------------------------");

  // public StringBuffer(String str):指定字符串内容的字符串缓冲区对象
  StringBuffer sb3 = new StringBuffer("hello");
  System.out.println("sb3:" + sb3);
  System.out.println("sb3.capacity():" + sb3.capacity());
  System.out.println("sb3.length():" + sb3.length());
 }
}



package cn.itcast_02;

/*
 * StringBuffer的添加功能:
 * public StringBuffer append(String str):可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身
 *
 * public StringBuffer insert(int offset,String str):在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身
 */
public class StringBufferDemo {
 public static void main(String[] args) {
  // 创建字符串缓冲区对象
  StringBuffer sb = new StringBuffer();

  // public StringBuffer append(String str)
  // StringBuffer sb2 = sb.append("hello");
  // System.out.println("sb:" + sb);
  // System.out.println("sb2:" + sb2);
  // System.out.println(sb == sb2); // true

  // 一步一步的添加数据
  // sb.append("hello");
  // sb.append(true);
  // sb.append(12);
  // sb.append(34.56);

  // 链式编程
  sb.append("hello").append(true).append(12).append(34.56);
  System.out.println("sb:" + sb);

  // public StringBuffer insert(int offset,String
  // str):在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身
  sb.insert(5, "world");
  System.out.println("sb:" + sb);
 }
}



package cn.itcast_03;

/*
 * StringBuffer的删除功能
 * public StringBuffer deleteCharAt(int index):删除指定位置的字符,并返回本身
 * public StringBuffer delete(int start,int end):删除从指定位置开始指定位置结束的内容,并返回本身
 */
public class StringBufferDemo {
 public static void main(String[] args) {
  // 创建对象
  StringBuffer sb = new StringBuffer();

  // 添加功能
  sb.append("hello").append("world").append("java");
  System.out.println("sb:" + sb);

  // public StringBuffer deleteCharAt(int index):删除指定位置的字符,并返回本身
  // 需求:我要删除e这个字符,肿么办?
  // sb.deleteCharAt(1);
  // 需求:我要删除第一个l这个字符,肿么办?
  // sb.deleteCharAt(1);

  // public StringBuffer delete(int start,int
  // end):删除从指定位置开始指定位置结束的内容,并返回本身
  // 需求:我要删除world这个字符串,肿么办?
  // sb.delete(5, 10);

  // 需求:我要删除所有的数据
  sb.delete(0, sb.length());

  System.out.println("sb:" + sb);
 }
}



package cn.itcast_04;

/*
 * StringBuffer的替换功能:
 * public StringBuffer replace(int start,int end,String str):从start开始到end用str替换
 */
public class StringBufferDemo {
 public static void main(String[] args) {
  // 创建字符串缓冲区对象
  StringBuffer sb = new StringBuffer();

  // 添加数据
  sb.append("hello");
  sb.append("world");
  sb.append("java");
  System.out.println("sb:" + sb);

  // public StringBuffer replace(int start,int end,String
  // str):从start开始到end用str替换
  // 需求:我要把world这个数据替换为"节日快乐"
  sb.replace(5, 10, "节日快乐");
  System.out.println("sb:" + sb);
 }
}



package cn.itcast_05;

/*
 * StringBuffer的反转功能:
 * public StringBuffer reverse()
 */
public class StringBufferDemo {
 public static void main(String[] args) {
  // 创建字符串缓冲区对象
  StringBuffer sb = new StringBuffer();

  // 添加数据
  sb.append("霞青林爱我");
  System.out.println("sb:" + sb);

  // public StringBuffer reverse()
  sb.reverse();
  System.out.println("sb:" + sb);
 }
}



package cn.itcast_06;

/*
 * StringBuffer的截取功能:注意返回值类型不再是StringBuffer本身了
 * public String substring(int start)
 * public String substring(int start,int end)
 */
public class StringBufferDemo {
 public static void main(String[] args) {
  // 创建字符串缓冲区对象
  StringBuffer sb = new StringBuffer();

  // 添加元素
  sb.append("hello").append("world").append("java");
  System.out.println("sb:" + sb);

  // 截取功能
  // public String substring(int start)
  String s = sb.substring(5);
  System.out.println("s:" + s);
  System.out.println("sb:" + sb);

  // public String substring(int start,int end)
  String ss = sb.substring(5, 10);
  System.out.println("ss:" + ss);
  System.out.println("sb:" + sb);
 }
}



package cn.itcast_07;

/*
 * 为什么我们要讲解类之间的转换:
 * A -- B的转换
 * 我们把A转换为B,其实是为了使用B的功能。
 * B -- A的转换
 * 我们可能要的结果是A类型,所以还得转回来。
 *
 * String和StringBuffer的相互转换?
 */
public class StringBufferTest {
 public static void main(String[] args) {
  // String -- StringBuffer
  String s = "hello";
  // 注意:不能把字符串的值直接赋值给StringBuffer
  // StringBuffer sb = "hello";
  // StringBuffer sb = s;
  // 方式1:通过构造方法
  StringBuffer sb = new StringBuffer(s);
  // 方式2:通过append()方法
  StringBuffer sb2 = new StringBuffer();
  sb2.append(s);
  System.out.println("sb:" + sb);
  System.out.println("sb2:" + sb2);
  System.out.println("---------------");

  // StringBuffer -- String
  StringBuffer buffer = new StringBuffer("java");
  // String(StringBuffer buffer)
  // 方式1:通过构造方法
  String str = new String(buffer);
  // 方式2:通过toString()方法
  String str2 = buffer.toString();
  System.out.println("str:" + str);
  System.out.println("str2:" + str2);
 }
}



package cn.itcast_07;

/*
 * 把数组拼接成一个字符串
 */
public class StringBufferTest2 {
 public static void main(String[] args) {
  // 定义一个数组
  int[] arr = { 44, 33, 55, 11, 22 };

  // 定义功能
  // 方式1:用String做拼接的方式
  String s1 = arrayToString(arr);
  System.out.println("s1:" + s1);

  // 方式2:用StringBuffer做拼接的方式
  String s2 = arrayToString2(arr);
  System.out.println("s2:" + s2);
 }

 // 用StringBuffer做拼接的方式
 public static String arrayToString2(int[] arr) {
  StringBuffer sb = new StringBuffer();

  sb.append("[");
  for (int x = 0; x < arr.length; x++) {
   if (x == arr.length - 1) {
    sb.append(arr[x]);
   } else {
    sb.append(arr[x]).append(", ");
   }
  }
  sb.append("]");

  return sb.toString();
 }

 // 用String做拼接的方式
 public static String arrayToString(int[] arr) {
  String s = "";

  s += "[";
  for (int x = 0; x < arr.length; x++) {
   if (x == arr.length - 1) {
    s += arr[x];
   } else {
    s += arr[x];
    s += ", ";
   }
  }
  s += "]";

  return s;
 }
}



package cn.itcast_07;

import java.util.Scanner;

/*
 * 把字符串反转
 */
public class StringBufferTest3 {
 public static void main(String[] args) {
  // 键盘录入数据
  Scanner sc = new Scanner(System.in);
  System.out.println("请输入数据:");
  String s = sc.nextLine();

  // 方式1:用String做拼接
  String s1 = myReverse(s);
  System.out.println("s1:" + s1);
  // 方式2:用StringBuffer的reverse()功能
  String s2 = myReverse2(s);
  System.out.println("s2:" + s2);
 }

 // 用StringBuffer的reverse()功能
 public static String myReverse2(String s) {
  // StringBuffer sb = new StringBuffer();
  // sb.append(s);

  // StringBuffer sb = new StringBuffer(s);
  // sb.reverse();
  // return sb.toString();

  // 简易版
  return new StringBuffer(s).reverse().toString();
 }

 // 用String做拼接
 public static String myReverse(String s) {
  String result = "";

  char[] chs = s.toCharArray();
  for (int x = chs.length - 1; x >= 0; x--) {
   // char ch = chs[x];
   // result += ch;
   result += chs[x];
  }

  return result;
 }
}



package cn.itcast_07;

import java.util.Scanner;

/*
 * 判断一个字符串是否是对称字符串
 * 例如"abc"不是对称字符串,"aba"、"abba"、"aaa"、"mnanm"是对称字符串
 *
 * 分析:
 *   判断一个字符串是否是对称的字符串,我只需要把
 *    第一个和最后一个比较
 *    第二个和倒数第二个比较
 *    ...
 *   比较的次数是长度除以2。
 */
public class StringBufferTest4 {
 public static void main(String[] args) {
  // 创建键盘录入对象
  Scanner sc = new Scanner(System.in);
  System.out.println("请输入一个字符串:");
  String s = sc.nextLine();

  // 一个一个的比较
  boolean b = isSame(s);
  System.out.println("b:" + b);
  
  //用字符串缓冲区的反转功能
  boolean b2 = isSame2(s);
  System.out.println("b2:"+b2);
 }
 
 public static boolean isSame2(String s) {
  return new StringBuffer(s).reverse().toString().equals(s);
 }
 

 // public static boolean isSame(String s) {
 // // 把字符串转成字符数组
 // char[] chs = s.toCharArray();
 //
 // for (int start = 0, end = chs.length - 1; start <= end; start++, end--) {
 // if (chs[start] != chs[end]) {
 // return false;
 // }
 // }
 //
 // return true;
 // }

 public static boolean isSame(String s) {
  boolean flag = true;

  // 把字符串转成字符数组
  char[] chs = s.toCharArray();

  for (int start = 0, end = chs.length - 1; start <= end; start++, end--) {
   if (chs[start] != chs[end]) {
    flag = false;
    break;
   }
  }

  return flag;
 }
}



package cn.itcast_08;

/*
 * 面试题:
 * 1:String,StringBuffer,StringBuilder的区别?
 * A:String是内容不可变的,而StringBuffer,StringBuilder都是内容可变的。
 * B:StringBuffer是同步的,数据安全,效率低;StringBuilder是不同步的,数据不安全,效率高
 *
 * 2:StringBuffer和数组的区别?
 * 二者都可以看出是一个容器,装其他的数据。
 * 但是呢,StringBuffer的数据最终是一个字符串数据。
 * 而数组可以放置多种数据,但必须是同一种数据类型的。
 *
 * 3:形式参数问题
 * String作为参数传递
 * StringBuffer作为参数传递
 *
 * 形式参数:
 *   基本类型:形式参数的改变不影响实际参数
 *   引用类型:形式参数的改变直接影响实际参数
 *
 * 注意:
 *   String作为参数传递,效果和基本类型作为参数传递是一样的。
 */
public class StringBufferDemo {
 public static void main(String[] args) {
  String s1 = "hello";
  String s2 = "world";
  System.out.println(s1 + "---" + s2);// hello---world
  change(s1, s2);
  System.out.println(s1 + "---" + s2);// hello---world

  StringBuffer sb1 = new StringBuffer("hello");
  StringBuffer sb2 = new StringBuffer("world");
  System.out.println(sb1 + "---" + sb2);// hello---world
  change(sb1, sb2);
  System.out.println(sb1 + "---" + sb2);// hello---worldworld

 }

 public static void change(StringBuffer sb1, StringBuffer sb2) {
  sb1 = sb2;
  sb2.append(sb1);
 }

 public static void change(String s1, String s2) {
  s1 = s2;
  s2 = s1 + s2;
 }
}


Powered by 东方博宜教育咨询江苏有限公司  ©2008-2017 www.czos.cn