java十五个常用类学习及方法举例

[java] view plain copy
 print?
  1.   
[java] view plain copy
 print?
  1. <code class="language-java">import java.util.Scanner;  
  2. import java.util.Properties;  
  3. import java.awt.SystemColor;  
  4. import java.util.Arrays;  
  5. import java.util.Random;  
  6. import java.text.DecimalFormat;    
  7. import java.math.BigInteger;  
  8. public class Tsar {  
  9.     public static void main(String []args){  
  10.     }  
  11. }  
  12. class BigIntegerTest{  
  13.     public static void main(String []args){  
  14.         BigInteger a = new BigInteger("-1000000");  
  15.         System .out.println("加法操作： "+a.add(new BigInteger("55")));  
  16.         System.out.println("取绝对值操作： "+a.abs());  
  17.     }  
  18. }  
  19.   
  20.   
  21. class RandomTest{  
  22.     public static void main(String []args){  
  23.         Random r = new Random();  
  24.         double d1 = r.nextDouble();  
  25.         System.out.println("随机产生一个双精度数 "+d1);  
  26.         System.out.println("随机产生一个0~10的整数  "+r.nextInt(10));  
  27.     }  
  28. }  
  29. class MathTest{  
  30.     public static void main(String []args){  
  31.         int x = 175;  
  32.         int y = -184;  
  33.    // 得到他们的绝对值  
  34.         System.out.println("Math.abs(" + x + ")=" + Math.abs(x));  
  35.         System.out.println("Math.abs(" + y + ")=" + Math.abs(y));  
  36.         double z = Math.PI / 2;  
  37.         z  = Math.toRadians(z);//将参数值转化为弧度  
  38.         System.out.println("Math.acos(" + z + ")=" + Math.acos(z));  
  39.     }  
  40. }  
  41.   
  42.   
  43. class FloatTest{  
  44.     public static void main(String []args){  
  45.          Float obj1 = new Float("10.56");  
  46.          Float obj2 = new Float("10.20");  
  47.          int retval =  obj1.compareTo(obj2);  
  48.          if(retval > 0)  
  49.             System.out.println("obj1 is greater than obj2");  
  50.          else if(retval < 0)  
  51.             System.out.println("obj1 is less than obj2");  
  52.          else   
  53.             System.out.println("obj1 is equal to obj2");  
  54.          float f = obj1.floatValue();  
  55.          System.out.println("Float对象obj1的float值 = " + f);  
  56.     }  
  57. }  
  58.   
  59.   
  60.   
  61.   
  62. class DoubleTest{  
  63.     public static void main(String []args){  
  64.         Double obj1 = new Double("20");  
  65.          byte b = obj1.byteValue();  
  66.          System.out.println("Value = " + b);  
  67.         Double obj2 = new Double("30.95");  
  68.          b = obj2.byteValue();  
  69.          System.out.println("Value = " + b);  
  70.          int retval = Double.compare(obj1, obj2);  
  71.          System.out.println("obj1和obj2 的比较结果为"+retval);  
  72.     }  
  73. }  
  74.   
  75.   
  76. class CharacterTest{  
  77.     public static void main(String []args){  
  78.          int cp = 0x12345;  
  79.          int res;  
  80.          res = Character.charCount(cp);  
  81.          System.out.println("输出比较值");  
  82.          System.out.println( res );  
  83.          Character a;  
  84.          a = new Character('a');  
  85.          Character ch = a.charValue();  
  86.          String str = "a的原始的字符值是 " + ch;  
  87.          System.out.println( str);  
  88.     }  
  89. }  
  90. class ByteTest{  
  91.     public static void main(String []args){  
  92.          Byte a,b;  
  93.          b = new Byte("100");  
  94.          a=  new Byte("10");  
  95.          int res;  
  96.          res = a.compareTo(b);  
  97.          byte bt;  
  98.          bt = b.byteValue();  
  99.          String str = "Primitive byte value of Byte object " + b + " is " + bt;  
  100.          System.out.println( str );  
  101.          System.out .print(res);  
  102.     }  
  103. }  
  104. class BooleanTest{  
  105.     public static void main(String []args){  
  106.         Boolean a,b;  
  107.         a = new Boolean(false);  
  108.         b = new Boolean(true);  
  109.         boolean bool;  
  110.         bool = b.booleanValue();  
  111.         String str = "Primitive value of Boolean object " + b + " is " + bool;  
  112.         System.out.println( str );  
  113.         int res;  
  114.         res = Boolean.compare(a, b);  
  115.         System.out.println(res);  
  116.     }  
  117. }  
  118. class ShortTest{  
  119.     public static void main(String []args){  
  120.         Short a = new Short((short)5);  
  121.         Short b = new Short((short)7);  
  122.         System.out.println(a.equals(b));  
  123.         String str = "78";  
  124.         //返回short型  
  125.         Short c = new Short(Short.valueOf(str));  
  126.         System.out.println(c);  
  127.     }  
  128. }  
  129. class LongTest{  
  130.     public static void main(String []args){  
  131.         Long a = new Long(56);  
  132.         Long b = new Long(43);  
  133.           
  134.         System.out.println(a.compareTo(b));  
  135.         String str[] ={"43","34","543"};  
  136.         long sum=0;  
  137.         for(int i=0;i<str.length ;i++){  
  138.             long c= Long.parseLong(str[i]);  
  139.             sum+=c;  
  140.         }  
  141.         System.out .println("输出数组各元素相加之和");  
  142.         System.out .println(sum);  
  143.     }  
  144. }  
  145. class IntegerTest{  
  146.     public static void main(String []args){  
  147.         Integer i = new Integer(12);  
  148.         int k = i.intValue(); //Integer转换成int   
  149.         System.out.println(k);  
  150.         k =  Integer.parseInt("13");  
  151.         System.out.println(k);//字符串转换成int类型    
  152.         k = Integer.parseInt("111",2);  
  153.         System.out.println("输出二进制111的十进制形式");  
  154.         System.out.println(k);  
  155.     }  
  156. }  
  157. class ArrayTest{  
  158.     public static void main(String []args){  
  159.         int arr[]={1,4,3,2,4,5};  
  160.         Arrays.sort(arr);//排序  
  161.         System.out.println("输出排序过后的数组");  
  162.         for(int i=0;i<=5;i++){  
  163.             System.out.print(arr[i]);  
  164.             System.out.print(" ");  
  165.         }  
  166.         System.out.println();  
  167.         int index = Arrays.binarySearch(arr, 3);  
  168.         System.out.println("3的索引位置是" + index);  
  169.     }  
  170. }  
  171. class StringTest{  
  172.     public static void main(String []args){  
  173.         System.out.println("统计字符串的长度");  
  174.         Scanner input=new Scanner(System.in);  
  175.         String str=input.nextLine();  
  176.         int size = str.length();  
  177.         System.out.println(size);  
  178.         System.out.println("对字符串实现小写转换");  
  179.         String str2 = str.toLowerCase();  
  180.         System.out.println(str2);  
  181.     }  
  182. }  
  183. class SystemTest{  
  184.     public static void main(String []args){  
  185.         long start = System.currentTimeMillis();  
  186.         String value = System.getProperty("os.name"); //获取环境的属性值  
  187.         System.out.println("当前系统"+value);   
  188.         long end = System.currentTimeMillis();  
  189.         System.out.println("运行本程序所需时间 "+(end-start));  
  190.     }  
  191. }  
  192. class ScannerTest{  
  193.     public static void main(String []args){  
  194.         System.out.println("请输入一个数：");  
  195.         Scanner input=new Scanner(System.in);  
  196.         int number=input.nextInt();  
  197.         System.out.println(number);  
  198.     }  
  199. }  
  200.   
  201.   
  202.   
  203.   
  204. </code>  

JAVA实验报告

学号  E31514034 专业  网络工程  姓名  陶硕  实验日期2017年3月14日

一．实验名称：

掌握java的十五个常用类

二．实验目的：

掌握JAVA常用类，包括Scanner类，System类，String类，Arrays类，Integer类，Long类，Short类，Boolean类，Byte类，Character类，Double类，Float类，DecimalFormat类，Math类，Random类，BigInteger类，BigDecimal类。

学习java的基本使用方式，熟练掌握java的操作方式。

发掘java语言和其他语言的相同之处，高效学习。

三．  实验平台:

Windows 8.164bit平台  JDK8  eclipse

四．  实验过程和结果分析：

   （一），Scanner类

  Scanner 类可以用来从键盘读取，可以输入任意类型的字符串，基本数据类型。

编写如下代码：

运行结果：

（二）。System类

System类位于java.lang包中，它是系统类，包含三个成员变量，分别是in，out，err，

他们的类型分别为InputStream，PrintStream，PrintStream，且都为静态的，分别代表标准输入流，标准输出流和标准错误输出流。其中最常用的就是out了。例如输出语句System.out,println()和System.out.print()，前者会换行，后者不会。此次列举两个方法：

 一个是获取当前系统的时间从而可以利用时间差求得程序的运行时间。

一个是可以直接获得本系统的属性

程序运行结果如下：

由程序结果可知本计算机的系统环境是windows8，程序运行时间为1；

（三）String类

可以通过java.lang包中的String类，在Java中将字符串作为对象来处理。

以下代码使用其中string类的其中两个方法，分别是大小写转换和统计长度。

程序运行结果：

输入的字符串为HELLO AHU，length返回长度，所以共计9个字符，tolowcase小写转换为hello ahu；

（四）Arrays类

使用Arrays类的方法需要用到Java.util包，包中包含了很多关于数组操作的方法

编写代码引用排序和索引位置的方法。

运行结果如下：

Sort输出数组从小到大的排列顺序，binarysearch利用二分的方法找到3在数组中的位置。如图所示。

 

（五）Integer类

Integer 类在对象中包装了一个基本类型 int 的值。Integer 类型的对象包含一个 int 类型的字段。此外，该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法。下面代码列举三个方法，分别是Integer转化为int类型和字符串转化为int型，还有一个是输出给定进制数值的十进制形式。

实验程序运行结果如下IntValue为Integer转化为int，ParseInt是将字符串转化为int型，也可以输出给定进制数值的十进制形式。

 

(六) Long 类

Java.lang包中的Long类，将基本类型long封装成一个类，它是Number的子类，Long类在对象中包装了一个基本类型long的值。此外，该类提供了多个方法，能在long类型和String类型之间互相转换，还提供了处理long类型时非常有用的其他一些常量和方法。下面列举两种方法。

A．compareTo(long  another Long)，在数字上比较两个Long对象，如果这两个值相等，则返回0，如果调用对象的值小于anotherLong的值，则返回负值，如果调用对象的数值大于anotherLong的数值，则返回正值。

B.  parseLong(String str)方法。该方法返回与调用该方法的数值字符串相应的长整数（返回值为long）。

编写以下代码：     

运行结果如下：

由于a>b,所以输出1，数组元素之和为620

（七）Short 类

    Java.lang包中的Short类，将基本类型short封装成一个类，它是Number的子类，Short类在对象中包装了一个基本类型short的值。此外，该类提供了多个方法，能在short类型和String类型之间互相转换，还提供了处理short类型时非常有用的其他一些常量和方法。下面阐述两种方法。

    1，equals(Object  ShortObj)方法，该方法是用于比较此对象与指定对象是否相等。返回值是boolean类型的值。

2，valueOf(String  str)方法，该方法返回保存制定制定String值的Short对象。

程序运行结果：

因为5不等于7，所以返回false。

输出short型78

（八）Boolean类

java.lang.Boolean类封装了一个值对象的基本布尔型。 Boolean类型的对象包含一个单一的字段中，其类型为布尔值。

类声明

以下是一个java.lang.Boolean类的声明：

public final class Boolean

   extends Object

      implements Serializable,Comparable

在此列举两个类方法：

1

boolean booleanValue() 
此方法返回一个布尔值，这个布尔对象作为原始值。

2

int compareTo(Boolean b) 
这种方法Boolean实例与另一个比较。

编写代码如图：

运行结果如下图：

第一个是返回这个布尔变量的原始值，第二个则是比较两个布尔变量，返回负数表示此对象表示false，参数表示true。

（九） Byte 类

java.lang.Byte类的基本类型byte值包装在一个对象中。 Byte类型的一个对象，包含一个单一的字段，它的类型是字节。

属性：

· static byte MAX_VALUE -- 保持的最大的值，可以有一个字节，这是恒定，最大值为： 27-1.

· static byte MIN_VALUE -- 保持可以有一个字节的最低值，这是一个恒定的，最大值为：-27.

· static int SIZE -- 这是用来表示一个字节的值在2补码二进制形式的比特的数目。

· static Class<Byte> TYPE -- 这是类的实例，原始类型字节。

此处列举两个类方法：

1

byte byteValue() 
此方法返回值的字节，一个字节

2

int compareTo(Byte anotherByte) 
这种方法比较两个Byte对象的数字

编写代码如下图所示：

运行结果如下图所示

因为b为100，所以返回字节值也是100，比较a和b，因为a小于b，所以返回负值。

(十) Character类

java.lang.Character类封装在一个对象的基本类型char值。字符类型的对象只包含一个字段，它的类型是char。列举两个方法：

1

static int charCount(int codePoint) 
这种方法的数量决定了需要的char值表示指定字符（Unicode代码点）。

2

char charValue() 
此方法返回值的字符对象。

编写代码如图所示：

输出结果如下图所示，因为Java.lang.Character.charCount()方法用法实例教程-数量决定了需要的char值表示指定character (Unicode code point)。指定字符是否是等于或大于0x10000的，那么该方法返回2。否则，该方法返回1。所以此结果输出2.而输出a 的原始字符值即a。

（十一）Double类

java.lang.Double类包装的原始类型的值的Double对象。 Double类型的对象只包含一个字段，它的类型是double。

编写代码如下图所示:

java.lang.Double.byteValue()方法返回此double值为一个字节（转换为一字节）。Compare则是比较obj1和obj2，如果obj1大于obj2，就返回大于0的数，等于返回0，小于返回小于0的数。

得到结果如下：

（十二）Float类

java.lang.Float 类封装了一个float基本类型的对象。Float类型的对象只包含一个字段的类型是float. 此外，该类还提供多个方法，可以将float转换为String，将String转换为float，也提供了其他一些处理float时有用的常量和方法。

列举两个方法：

1.      Java.lang.Float.compareTo()方法

2.      Java.lang.Float.floatValue()方法 

编写代码如下图所示：

因为方法一是比较两个Float对象的数值，方法二是返回当前Float对象的float值.，所以输出应该是以下输出;

（十三）. Math类

java.lang.Math 类包含的方法进行基本的数字操作，如基本的指数，对数，平方根和三角函数等. Math提供了一些常量，E，表示自然对数，PI表示圆周率，均为double型。下面列举两种方法：

1.      staticint abs(int a)  此方法返回一个int值的绝对值.

2.      static double acos(double a)此方法返回一个值的反余弦值，返回的角度范围从0.0到pi.

编写代码如下图所示：

Math.abs求绝对值，然后acos是返回一个值的余弦值，运行结果如下图所示：

（十四）Random类

Random类中实现的随机算法是伪随机，也就是有规则的随机。在进行随机时，随机算法的起源数字称为种子数(seed)，在种子数的基础上进行一定的变换，从而产生需要的随机数字。相同种子数的Random对象，相同次数生成的随机数字是完全相同的。也就是说，两个种子数相同的Random对象，第一次生成的随机数字完全相同，第二次生成的随机数字也完全相同。这点在生成多个随机数字时需要特别注意。

列举两种方法：

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

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

编写代码如下图所示：

运行结果如下：

（十五）BigInteger类

BigInteger类属于java.math包，该类型的数字较Integer类型的数字范围要大的多。BigInteger类支持任意精度的整数。BigInteger类中包含三个成员变量，分别为ONE，表示BigInteger 的常量 1。TEN，表示BigInteger 的常量10。ZERO，表示BigInteger 的常量 0。且它们都是static BigInteger类型。在BigInteger类中封装了多种操作，除了基本的加，减，乘，除运算之外，还提供了绝对值，相反数，最大公约数以及判断是否为质数的操作。

下面举例两种方法：

1.      abs，取大数的绝对值

2.      and，大数的加法

编写代码如下图所示：

运行结果：输出-1000000+55的值和它自己本身的绝对值，如下图所示

五，实验小结：

   这次实验操作数量很多，做的很辛苦，但是做完之后收获也很大，初步理解了十五种常用类的使用方法。对java的操作愈加娴熟，对于常用类的了解也愈加深厚，发现了很多java具备的其他例如C语言没有的好属性，为以后的学习打下了深厚的基础。希望在以后的学习中java能带来更多的收获。



【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/jpfss/p/9674124.html