Java基础----一其他类的总结（一）

  总结这些类之前，先介绍一下JDK提供的API（应用程序编程接口----帮助文档）。一接下来要总结的Math类为例。

           步骤：

                    A：找到文档，打开文档。

                    B：点击左上角的显示变成隐藏，然后点击索引。

                   C：你应该知道你要找谁？ 如Math ，所以，你就在那个输入框中输入Math，然后回车再回车。

                    D：看这个类的结构     

                                                         java.lang 

                                                                         类Math

                                                           java.util

                                                                         类Scanner

                                           如果是java.lang包下的类，是可以直接使用的。（如Math）否则，就需要导包才能使用。（如Scanner）

                      E：看看对这个类的说明。

                      F：看构造方法

                                         名称：字段    — — — —   成员变量         — — — —  属性

                                          a：有构造方法，那么就通过构造方法创建对象使用。

                                          b：没有构造方法，那么这个类的成员一般都是静态。

                      G：按照正常的操作使用方法。

                                           左边：是否静态： 如果静态修饰，那么可以通过类名调用。否则就必须创建对象调用。

                                                       是否有明确返回值：如果是void类型，就直接用即可。否则，就可以输出或者赋值。

                                           右边：看方法名：不要写错了。

                                                         看参数：看参数类型及个数。       

        个人思考：我觉得学习API最重要的就是：看到一个方法，你如何把它正确使用了。 

                 

  接下来介绍一下java中的一些常用的类：

                                                                         第一个：Math类  

              （1）介绍： 从API中可以查到，Math类的介绍：Math 类包含用于执行基本数学运算的方法。 

                              如初等指数、对数、平方根和三角函数。

           （2）比较常用的几个方法：                  

                                           1、double　ceil(double d);//返回大于指定数据的最小整数

                                           2、double　floor(double d);//返回小于指定数据的最大整数

                                           3、double 　pow(doublea,double b);//返回a的b次方

                                           4、long 　round(doubleb);//返回b四舍五入的值 

                                           5、double　random();//返回正号的double值，是一个大于等于0.0且小于1.0的随机数

  手敲代码练习一下：                         

class MathDemo{//static int x = 10;public static void main(String[] args){//成员常量//System.out.println(Math.E);//System.out.println(Math.PI);//成员方法//绝对值System.out.println(Math.abs(-12));//大于等于参数的最小整数,返回类型是doubleSystem.out.println(Math.ceil(12.3));System.out.println(Math.ceil(12.7));//小于等于参数的最大整数,返回类型是doubleSystem.out.println(Math.floor(12.3));System.out.println(Math.floor(12.7));//四舍五入的System.out.println(Math.round(12.3f));System.out.println(Math.round(12.7f));//随机数System.out.println(Math.random());//两个数中的最大值,最小值自学。System.out.println(Math.max(12,23));//三个数中的最大值,12,23,18System.out.println(Math.max(Math.max(12,23),18));}}

                                                                 

                                                           第二个：Random类 (java.util) 

       概述：此类的实例用于生成伪随机数流，也就是有规则的随机。在进行随机时，随机算法的起源数字称为种子数(seed)，在种子数的基础上进行一定的变换，从而产生需要的随机数字。

         相同种子数的Random对象，相同次数生成的随机数字是完全相同的。也就是说，两个种子数相同的Random对象，第一次生成的随机数字完全相同，第二次生成的随机数字也完全相同。这点在生成多个随机数字时需要特别注意。

下面介绍一下Random类的使用，以及如何生成指定区间的随机数组以及实现程序中要求的几率。

       A：构造方法

                       public   Random（）：使用默认种子。当前时间的毫秒值，每次产生的随机数都是变化的。

                       public    Random（long seed）： 如果给定了种子，每次都是按照种子给出初始值产生的随机数，如果种子是固定的，那么只是一样的。

                  示例代码：

                      Random r = new Random();

                      Random r1 = new Random(10);

                 再次强调：种子数只是随机算法的起源数字，和生成的随机数字的区间无关。

      B：成员方法    Random类中各方法生成的随机数字都是均匀分布的，也就是说区间内部的数字生成的几率是均等的。

               public boolean  nextBoolean()：该方法的作用是生成一个随机数的boolean值，生成true和false的值几率相等，也就是都是50%的几率。

               public  int  nextInt ()：int 范围内的一个数据，该值介于int的区间，也就是-231到231-1之间。

               public  int nextInt（int  n）： 在0 到n范围内的一个数据，包括0，不包括n。

               public double  nextDouble() ：该方法的作用是生成一个随机的double值，数值介于[0，1.0]之间。

               public void setSeed（long seed）：该方法的作用是重新设置Random对象中的种子数。

                         设置完种子数以后的Random对象和相同种子数使用new关键字创建出的 Random对象相同。

附加：关于Math类中的random方法

          其实在Math类中也有一个random方法，该random方法的工作是生成一个[0,1.0] 区间的随机小数。

          通过阅读Math类的源代码可以发现，Math类中的random方法就是直接调用Random类中的nextDouble方法实现的。

          只是random方法调用比较简单，所以很多程序员都习惯使用Math类的random方法来生成随机数字。

       

            获取一个1-100之间的随机数：
A: int num = (int)(Math.random()*100)+1   （一般都用这个）
B: Random r = new Random();
     int num = r.nextInt(100)+1;

      一个练习的代码 ：

import java.util.Random;class RandomDemo{public static void main(String[] args){//创建对象//Random r = new Random();Random r = new Random(17);//调用功能//System.out.println(r.nextInt());/*for(int x=0; x<1000; x++){System.out.println(r.nextInt(100));}*/for(int x=0; x<10; x++){int num = r.nextInt(100);System.out.println(num);}}}

                                                                                                   

                                                                                                         第三个：Object类

                                                                             

————java.lang.object

     Object：所有类的直接或间接父类，Java认为所有的对象都具备一些基本的共性内容，这些内容可以不断的向上抽取，最终就抽取到了一个最顶层的类中的，该类中定义的就是所有对象都具备的功能。

具体方法：

             1、boolean equals(Object  obj)：用于比较两个对象是否相等，其实内部比较的就是两个对象地址。

 而根据对象的属性不同，判断对象是否相同的具体内容也不一样，所以在定义类时，一般都会复写equals方法，建立本类特有的判断对象是否相同的依据。         

             public boolean equals(Object obj){        //默认比较的是对象的地址值是否相同。 一般对重写该方法，按照自己的需求进行比较。

                if(!(obj instanceof Person))

                    return false;

             Person p = (Person)obj;

               return this.age == p.age;

     }

             2、String  toString() ：将对象变成字符串；默认返回的格式：类名@哈希值 = getClass().getName() + '@' + Integer.toHexString(hashCode())

为了对象对应的字符串内容有意义，可以通过复写，建立该对象自己特有的字符串表现形式。推荐自己重写tostring()方法。

    public String toString(){        //返回对象的字符串表示形式。   组成：包名...类名@哈希值的十六进制

       return "person : "+name;

   }

        3、Class  getClass()： 获取任意对象运行时的所属字节码文件对象。

        4、int hashCode()：返回该对象的哈希码值，支持此方法是为了提高哈希表的性能。 是根据对象的地址值计算出来的一个队员的整数值。可以理解为地址值。

通常equals，tostring，hashCode  在应用中都会被复写，建立具体对象的特有的内容。

       5、一道面试题：  ==和equals()的区别？

               ==：比较基本类型：比较的是基本类型的值是否相同。

              比较引用类型：比较的是引用类型的地址值是否相同。

public class StudentTest2 {public static void main(String[] args) {int x = 10;int y = 10;// 基本类型的比较System.out.println(x == y);// trueStudent s1 = new Student();Student s2 = new Student();Student s3 = s1;// 引用类型的比较System.out.println(s1 == s2);// falseSystem.out.println(s1 == s3);// true}}

equals：比较引用类型，默认比较的是引用类型的地址值是否相同。如果类重写了该方法，那就得按照重写后的规则进行比较。

/** * 需求：写一个功能，要求实现学生的年龄是否相同。 * 思路：用Object类的equals()方法去比较。 *///标准的学生类class Student{private String name;private int age;public Student() {}private  Student(String name,int age) {this.age=age;this.name=name;}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;}@Overridepublic String toString() {//return "Student [name=" + name + ", age=" + age + "]";  return "name:"+name+",age:"+age;}//重写equals一般就是为了比较某个类的多个对象的所有成员变量值是否相同//如果成员变量是基本类型，就用==比较//如果成员变量时引用类型,就用该变量对应的引用类型的equals（）方法@Overridepublic boolean equals(Object obj) {//为了提高代码效率if (this == obj){return true;}//为了提高程序的健壮性，加一个判断：判断传递过来的对象是否是Student类型的。//怎么判断？格式：对象名 instanceof 类  判断对象是否是该类的对象，返回boolean类型if(!(obj instanceof Student)){return false;}Student s=(Student)obj;return this.age==s.age&&this.equals(s.name);}}public class StudentTest {   public static void main(String[] args) {   //创建两个学生对象Student s1=new Student();s1.setName("高圆圆");s1.setAge(35);Student s2=new Student();s2.setName("孙俪");s2.setAge(30);boolean flag=s1.equals(s2);System.out.println(flag);   //结果返回的是false  }}

                                                                                                       

                                                                                       第四个：Scanner类

     Scanner是SDK1.5新增的一个Java.util.Scanner类，这是一个用于扫描输入文本的新的实用程序，它是以前的StringTokenizer和Matcher类之间的某种结合。由于任何数据都必须通过同一模式的捕获组检索或通过使用一个索引来检索文本的各个部分。于是可以结合正则表达式和从输入流中检索特定类型数据项的方法。这样，除了能使用正则表达式之外，Scanner类还可以任意地对字符串和基本类型（如int 和double）的数据进行分析。借助于Scanner，可以针对任何要出来的文本内容编写自定义的语法分析器。

    

（1）Scanner的基本使用方法：

常用构造方法：

Scanner(File source) //构造一个新的Scanner，它生成的值是从指定文件扫描的
Scanner(InputStream source) //构造一个新的 Scanner，它生成的值是从指定的

                             输入流扫描的
Scanner(String source) //构造一个新的Scanner，它生成的值是从指定字符串

                          扫描的。

 

先介绍几个重要的成员方法：

int nextInt(); //将输入信息的下一个标记扫描为一个 int

double nextDouble(); //将输入信息的下一个标记扫描为一个double

   ...

String nextNext();  //查找并返回来自此扫描器的下一个完整标记(字符串）

String nextLine();  //此扫描器执行当前行，并返回跳过的输入信息

   ...

boolean hasNext();  //如果此扫描器的输入中有另一个标记，则返回true

boolean hasNext(Pattern pattern); //如果下一个完整标记与指定模式匹配，则

                                   返回true

boolean hasNext(String pattern); //如果下一个标记与从指定字符串构造的模式

                                   匹配，则返回true

boolean hasNextInt(); //如果通过使用nextInt()方法，此扫描器输入信息中的下

                   一个标记可以解释为指定基数中的一个int 值，则返回true。

   ...

import java.util.Scanner;/* * int -- int正常 * String -- String正常 * String -- int正常 * int -- String不正常 *  * 如何解决这个不正确的情况： * A:重新创建一个Scanner对象。 * B:都用字符串接收，然后把一个字符串转换成int类型。 */public class ScannerDemo2 {public static void main(String[] args) {// 创建对象Scanner sc = new Scanner(System.in);// 获取两个int类型数据int a = sc.nextInt();// int b = sc.nextInt();//对sc对象重新赋值sc = new Scanner(System.in);// 获取两个字符串类型// String a = sc.nextLine();String b = sc.nextLine();// int b = sc.nextInt();System.out.println(a + "***" + b);}}

                                                                                                              

                                                                      第五个：String类

字符串：有多个字符组成的序列。  如：String  s="Hello";

String类代表的是一个字符串。字符串对象在开发中是最常见的，为了方便我们对象字符串的操作，java就把字符串用对象进行了封装。这个封装类就是String类。

   String 类的构造方法：  空构造    、 参数为字节数组 、参数为字符数组 

     下面把几个常用的方法列出来：

                A:     String s = new String();
B:     String s = new String(byte[] bys);
C:    String s = new String(byte[] bys,int index,int length);
D:    String s = new String(char[] chs);
E:    String s = new String(char[] chs,int index,int length);
F:    String s = new String(String str);
G:   String s = "hello";

 

字符串的特点及面试题

            A：字符串一旦被赋值，就不能改变。注意：字符串的值不能改变，没有说引用变量不能改变。

            B：面试题：

                  1、String s=new  String ("Hello") 和String  s="hello" 的区别。 

                          答：有，  第一种方式，其实在内存中有两个对象存在。   第二种方式，在内存中只有一个对象存在。

                                 我自己的理解是：new出来的对象一般都会存放在堆中，而给该对象赋的值会放在字符串常量池里面，只是new出来的对象的地址会去常量池里面找，找到对应的了，就会让指针指向该地址；  而第二种方式是直接给s赋值，直接去常量池里面找就行了，直接指向该值的地址。

                 2、根据一下代码，写出编译结果：

public static void main(String[] args) {String s1 = new String("hello");String s2 = new String("hello");System.out.println(s1 == s2);System.out.println(s1.equals(s2));System.out.println("-----------");String s3 = new String("hello");String s4 = "hello";System.out.println(s3 == s4);System.out.println(s3.equals(s4));System.out.println("-----------");String s5 = "hello";String s6 = "hello";System.out.println(s5 == s6);System.out.println(s5.equals(s6));}

 我个人理解：（1）、 s1和s2是两个不同的对象，它们的地址值不同，直接比较s1==s2   其实比较的是其地址值，所以肯定为false,而equals方法就是判断两个字符串的值是否相同，只要相同就为true， （2)、s3和s4也是两个不同的对象，其地址不相同，所以结果肯定是false，  （3）s5和s6两个都是直接指向”hello“ 所以其地址相同。

综上可以得出结果为：

                    

  成员方法
A:判断功能
booleanequals(Object obj)    判断字符串的内容是否相同,区分大小写。
booleanequalsIgnoreCase(String str)   判断字符串的内容是否相同,不区分大小写。
booleancontains(String str )      判断字符串对象是否包含给定的字符串
booleanstartsWith(String str)      判断字符串对象是否以给定的字符串开始
booleanendsWith(String str)      判断字符串对象是否以给定的字符串结束。
booleanisEmpty()     判断字符串对象是否为空。数据是否为空。
B:获取功能
int   length()    获取字符串的长度
char   charAt(int index)      返回字符串中给定索引处的字符
int   indexOf(int ch)     返回指定字符在此字符串中第一次出现的索引
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)      截取字符串。返回从指定位置开始到指定位置结束截取后的字符串。
C:转换功能
byte[]  getBytes()     把字符串转换成字节数组。
char[]  toCharArray()     把字符串转换成字符数组。
static  String copyValueOf(char[] chs)     把字符数组转换成字符串。
static  String valueOf(char[] chs)     把字符数组转换成字符串。
static  String valueOf(int i)      基本类型：把int（基本类型）转换成字符串
String  toLowerCase()      把字符串变成小写
String  toUpperCase()      把字符串变成大写
String  concat(String str)   拼接字符串。
D:其他功能
a:替换功能
String  replace(char oldChar , char newChar)用新的字符去替换指定的旧字符
String replace(String oldString , String newString)用新的字符串去替换指定的旧字符串

b:切割功能
String[]split(String regex)

      c:去除两端空格功能
String trim()

     d:字典顺序比较功能
 int compareTo(String str)
int compareToIgnoreCase(String str) 

以下是几个相关的小练习：

案例一：写一个程序，模拟用户登录。

/* * 模拟登录,给三次机会,并提示还有几次 *  * 思路： * A:应该已经存在有用户名和密码。用String表示就可以。 * B:键盘录入数据：用户名和密码。 * C:把数据进行比较。 * 匹配：成功 * 不匹配：失败。 *D:给三次机会，说明用循环控制。而告诉你了三次。用for循环。 *E:提示还有几次。其实很简单。 */public class StringTest {public static void main(String[] args) {// 应该已经存在有用户名和密码。用String表示就可以。String username = "admin";String password = "admin";// 三次机会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 (username.equals(name) && password.equals(pwd)) {System.out.println("恭喜你,登录成功");// 引入曾经的猜数字小游戏。break;} else {if ((2 - x) == 0) {System.out.println("账号被锁定,请与管理员联系");} else {// 2,1,0System.out.println("登录失败,你还有" + (2 - x) + "次机会");}}}}}

案例二：写一个程序，统计大写小写字符的个数。

/* * 统计大写小写字符的个数 *  * 举例： * Hello12345World *  * 大写：2 * 小写：8 * 数字：5 *  * 思路： * A:定义三个统计变量 * B:获取到每一个字符。遍历字符串。 * C:判断是属于哪种范围的 * 大写：65-90 * 小写：97-122 * 数字：48-57 *C:是哪种哪种++ */public class StringTest {public static void main(String[] args) {String s = "Hello12345World";// 定义三个统计变量int bigCount = 0;int smallCount = 0;int numberCount = 0;// 遍历字符串。for (int x = 0; x < s.length(); x++) {char ch = s.charAt(x);// 判断是属于哪种范围的//if (ch >= 65 && ch <= 90) {//bigCount++;//} else if (ch >= 97 && ch <= 122) {//smallCount++;//} else if (ch >= 48 && ch <= 57) {//numberCount++;//}if (ch >= 'A' && ch <= 'Z') {bigCount++;} else if (ch >= 'a' && ch <= 'z') {smallCount++;} else if (ch >= '0' && ch <= '9') {numberCount++;}}System.out.println("大写：" + bigCount);System.out.println("小写：" + smallCount);System.out.println("数字：" + numberCount);}}

案例三：把字符串的首字母转成大写，其余为小写。

/* * 需求:把字符串的首字母转成大写，其余为小写 *  * 举例： * helloWorld *  * 结果： * Helloworld *  * 思路： * A:截取首字母。 * B:截取其他字母。 * C:把A转大写+B转小写 */public class StringTest {public static void main(String[] args) {String s = "helloWorld";String s1 = s.substring(0, 1);String s2 = s.substring(1);String s3 = s1.toUpperCase().concat(s2.toLowerCase());System.out.println(s3);// 链式编程// String result = s.substring(0, 1).toUpperCase()// .concat(s.substring(1).toLowerCase());// System.out.println(result);}}

<span style="font-weight: bold; font-family: Arial, Helvetica, sans-serif; font-size: 12px; background-color: rgb(255, 255, 255);">案例四：写一个程序，实现获取一个字符串中指定子串出的次数。比如说“hanbasdnbafllgnbahjnbakqqqqlnbaxi” 在这个字符串中，多有个nba？</span>

/* * 获取一个字符串中指定子串出的次数。比如说“hanbasdnbafllgnbahjnbakqqqqlnbaxi” 在这个字符串中，多有个nba？ */public class StringTest2 {public static void main(String[] args) {String str = "hanbasdnbafllgnbahjnbakqqqqlnbaxi";String regex = "nba";// 功能int count = getCount(str, regex);System.out.println(count);}/* * 返回值：统计变量的值 int 参数列表：大串和小串 */public static int getCount(String maxString, String minString) {// 定义统计变量int count = 0;// 在大串中查找小串一次int index = maxString.indexOf(minString);// 如果返回值不是-1，说明小串在大串中是存在的。while (index != -1) {// 统计变量++count++;// 把查找过的数据给截取掉,重新赋值给大串maxString = maxString.substring(index + minString.length());// 在新的大串中查找一次小串index = maxString.indexOf(minString);}return count;}public static int getCount2(String maxString, String minString) {// 定义统计变量int count = 0;int index = 0;// 查找，赋值，判断while ((index = maxString.indexOf(minString)) != -1) {// 统计变量++count++;// 把查找过的数据给截取掉,重新赋值给大串maxString = maxString.substring(index + minString.length());}return count;}}

案例五：对字符串中字符进行自然排序。

/* * 对字符串中字符进行自然排序： * "basckd" -- "abcdks" * *思路： *A:把字符串变成字符数组 *B:对字符数组进行排序 *C:把排序后的字符数组转换成字符串 */public class StringTest3 {public static void main(String[] args) {String s = "basckd";// 把字符串变成字符数组char[] chs = s.toCharArray();// 对字符数组进行排序bubbleSort(chs);// 把排序后的字符数组转换成字符串/* * 方式1：构造方法 * 方式2:静态方法 copyValueOf() * 方式3:静态方法 valueOf() */String result = new String(chs);System.out.println(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 ch = chs[y];chs[y] = chs[y + 1];chs[y + 1] = ch;}}}}}