侧边栏壁纸
博主头像
coydone博主等级

记录学习,分享生活的个人站点

  • 累计撰写 306 篇文章
  • 累计创建 51 个标签
  • 累计收到 0 条评论

目 录CONTENT

文章目录

API和包装类

coydone
2021-01-18 / 0 评论 / 0 点赞 / 387 阅读 / 10,441 字 / 正在检测是否收录...
温馨提示:
本文最后更新于 2022-05-01,若内容或图片失效,请留言反馈。部分素材来自网络,若不小心影响到您的利益,请联系我们删除。

Java API概述

Java API(Java Application Programming Interface)即Java应用程序编程接口,它是运行库的集合,预先定义一些接口和类,程序员可以直接使用这些已经被打包的接口和类来开发具体的应用,节约了程序员大量的时间和精力。API还特指API的说明文档,也称帮助文档。

我们学习Java编程面对两种类:我们自己写的类、用其他人写好的类来使用。

API是把JDK里面提供好的类梳理成了一个文档,方便我们来查阅。

基本信息

类的属性的摘要

类的构造器的摘要

方法的摘要

从父类继承下来的方法

Java API中常用的包

java.lang:编写java程序时最广泛使用的包,自动导入到所有的程序中,包含了java程序的基础类和接口。包装类、Math类、String类等常用的类都包含在此包中,java.lang包还提供了用于管理类的动态加载、外部进程创建、主机环境查询和安全策略实施等“系统操作”的类。

java.util:包含了系统辅助类,特别是Collection、List和Map等集合类。

java.io:包含了与输入/输出有关的类,如文件操作等类。

java.net:包含了与网络有关的类,如Socket、ServerSocket等类。

java.sql:包含了与数据库相关的类,如Connection、Statement等类。

java.lang包中常用类

String类

/*
    String类的特点:
	    String 类代表字符串。
	    Java 程序中的所有字符串字面值(如 "abc" )都作为此类的实例实现。 
        字符串是常量;它们的(双引号括起来字符串)值在创建之后不能更改

    String类构造方法 
        String(String original) 
    String类的  boolean equals(Object obj)
        重写了Object类中的equals方法,比较的是两个字符串的内容,不再比较地址值
 */
public class Demo {
    public static void main(String[] args) {
        //method01();   
        //method02();

        String s1 = "abc";
        String s2 = new String("abc");
        System.out.println(s1 == s2);//false
        System.out.println(s1.equals(s2));//true
    }

    private static void method02() {
        String s1 = "abc";
        String s2 = "abc";
        System.out.println(s1 == s2);//s1与s2比较的是内存地址值,s1,s2引用都是常量池中的同一个abc,所以地址值相同
        System.out.println(s1.equals(s2));//true 比较的是两个字符串内容
    }

    private static void method01() {
        String str = new String("abc");
        System.out.println(str.toString());

        String s1 = "abc";
        String s2 = "def";
        boolean b = s1.equals(s2);
        System.out.println(b);
    }
}

String内存图解

1、字面量形式

2、new对象形式

String类中的转换

字符数组和字符串的相互转换

大小写转换

String toUpperCase():使用默认语言环境的规则将此String中的所有字符都转换为大写。

String toLowerCase():使用默认语言环境的规则将此String中的所有字符都转换为小写。

/* String类的转换功能:
   1.字符串和字符数组相互转换
      字符数组-->字符串
         String(char[] value)
         String(char[] value, int offset, int count)
              offset:从字符数组第几个索引位置开始
              count:获取多少个字符
                   字符串->字符数组
         char[] toCharArray()
                将此字符串转换为一个新的字符数组。
    2.转换大小写
       String toLowerCase():将字符串中所有的字符全部转为小写
       String toUpperCase():将字符串中所有的字符全部转为大写
 */
public class Test {
    public static void main(String[] args) {
        method01();
        //method02();
        //method03();
    }

    //大小写转换
    public static void method03() {
        String str = "aBCd";
        str.toLowerCase();
        //打印的还是原始字符串,因为"aBCd"一经初始化不可改变
        System.out.println(str); //aBCd

		
//不会改变原有字符串,而是产生一个新的字符串
        String lowerStr = str.toLowerCase();
        //相当于String lowerStr="abcd"
        System.out.println(str);//aBCd
        System.out.println(lowerStr);//abcd

        String upperStr = str.toUpperCase();//不会改变原有字符串
        //相当于String upperStr="ABCD"
        System.out.println(str);//aBCd
        System.out.println(upperStr);//ABCD
    }

    //字符串->字符数组  为了使用字符数组的索引,可以考虑将字符串转成字符数组
    public static void method02() {
        String str = "def";
        char[] charArr = str.toCharArray();//{'d','e','f'}
        for (int i = 0; i < charArr.length; i++) {
            System.out.println(charArr[i]);
        }//d  e   f

		//"ghk"字符串常量就是一个字符串对象
        char[] chArr = "ghk".toCharArray();
        for (int i = 0; i < chArr.length; i++) {
            System.out.println(chArr[i]);
        }//g  h  k
    }

    //字符数组->字符串,当我们想使用字符串中的一些方法的时候,可以利用这个转换
    public static void method01() {
        char[] chArr = {'a', 'c', 'd'};
        //将字符数组中的内容放在字符串中
        String str = new String(chArr);
        System.out.println(str);//acd
        //从1索引位置开始,将2个字符转换为字符串(包含1索引的字符)
        String str2 = new String(chArr, 1, 2);
        System.out.println(str2);//cd

        //从1索引位置开始,将2个字符转换为字符串(包含1索引的字符)
        //String str3=new String(chArr,1,3);
        //System.out.println(str3);  //StringIndexOutOfBoundsException
    }
}

String类中的判断

判断字符串开始或结束字符串:

boolean startsWith(String prefix):测试此字符串是否以指定的前缀开始。

boolean endsWith(String suffix):测试此字符串是否以指定的后缀结束。

String str = "StringDemo.java";
boolean b1 = str.startsWith("Demo");//判断是否以给定字符串开头
boolean b2 = str.startsWith("String");
boolean b3 = str.endsWith("java");//判断是否以给定字符串结尾

判断字符串是否包含指定子串:

boolean contains(CharSequence s):当且仅当此字符串包含指定的char值序列时,返回true。

String str = "abcde";
boolean b2 = str.contains("bcd");
//判断是否包含指定字符串,包含返回true,不包含返回false

判断两个字符串中的内容是否相同:

boolean equals(Object anObject):将此字符串与指定的对象比较。

boolean equalsIgnoreCase(String anotherString):将此String与另一个String比较,不考虑大小写 。

String str = "abcde";
String str2 = "abcde";
String str3 = "hello";
boolean b1 = str.equals(str2);
boolean b2 = str.equals(str3);

String类中的获取功能

获取字符串长度 : length(),返回int型的字符串的长度。

获取部分字符串:

  • String substring(int beginIndex):返回一个新的字符串,它是此字符串的一个子字符串。

  • String substring(int beginIndex,int endIndex):返回一个新字符串,它是此字符串的一个子字符串。

public static void main(String[] args) {
	String str = "abcde";
    String s1 = str.substring(1); 
    //返回一个新字符串,内容为指定位置开始到字符串末尾的所有字符
    String s2 = str.substring(2, 4);
    //返回一个新字符串,内容为指定位置开始到指定位置结束所有字符
    System.out.println("str="+str);//str=abcde
    System.out.println("s1="+s1);//s1=bcde
    System.out.println("s2="+s2);//s2=cd
}

其它获取功能

/*
 *String 类的获取功能:
 *   int length() //获取字符串中的字符个数 
 *   char charAt(int index)//获取指定位置的字符
 *   String substring(int start)//获取字符串中指定索引开始的子串
 *   String substring(int start,int end)//获取从start到end-1的字符串,包含start以及end-1的字符 
 *   String trim() //去除首尾的空白字符  
 *   int indexOf(String str)//拿着指定的字符串作为子串去调用indexOf的字符串中查找,返回第一次找到子串的位置
 * 		//如果不存在这个子串,返回-1
 *   int lastIndexOf(String str)//拿着指定的字符串作为子串去调用lastIndexOf的字符串中倒着查找,返回第一次找到子串的位置
 *  //如果不存在这个子串,返回-1,注意返回的索引位置是将字符串从起始位置编号
 */

/*
	连接字符串	concat()
	拆分字符串	split()
*/

枚举

枚举类型可以取代以往常量的定义方式,即将常量封装在类或接口中。此外,枚举类型还提供了安全检查功能。枚举类型本质上还是以类的形式存在。

使用enum关键字定义

public enum EnumDemo {
    MON,TUE,WED,THU,FRI,SAT,SUN
}

用户可以将一个枚举类型看作是一个类,它继承于java.lang.Enum类,当定义一个枚举类型时,每一个枚举类型成员都可以看作是枚举类型的一个实例,这些枚举类型成员默认都被final、public、static所修饰,所以当使用枚举类型成员时直接使用枚举类型名称调用枚举类型成员即可。

enum Week {
    MON, TUE, WED, THU, FRI, SAT, SUN
}

class WeekDemo {
    public void doWhat(Week day) {
        switch (day) {
            case MON:
            case TUE:
            case WED:
            case THU:
            case FRI:
                System.out.println("1-5");
                break;
            case SAT:
            case SUN:
                System.out.println("6-7");
                break;
            default:
                System.out.println("数字不是1-7的整数");
        }
    }
}

public class EnumDemo {
    public static void main(String[] args) {
        WeekDemo weekDemo = new WeekDemo();
        weekDemo.doWhat(Week.FRI);//1-5
        Week day = Week.SAT;
        weekDemo.doWhat(day);//6-7
		
		//枚举遍历
		for(Week value:Week.values()){
			System.out.println(value);
		}
    }
}

包装类

Java语言是面向对象的,但是Java中的基本数据类型却不是面向对象的,这在实际开发中存在很多的不便,为了解决这个不足,在设计类时为每个基本数据类型设计了一个对应的类,称为包装类(Wrapper Class)。

包装了均位于java.lang包中,包装类和基本数据类型的对应关系如下:

基本数据类型 包装类型
byte Byte
boolean Boolean
short Short
char Character
int Integer
long Long
float Float
double Double

Integer主要的字段(即属性)

  • static int MAX_VALUE 值为2^31-1的常量,它表示int类型能够表示的最大值。

  • static int MIN_VALUE 值为-2^31的常量,它表示int类型能够表示的最小值。

Integer构造方法

  • Integer(int value):构造一个新分配的Integer对象,它表示指定的int值。

  • Integer(String s):构造一个新分配的Integer对象,它表示String参数所指示的int值。

Integer常用的方法:将string类型转换为int

  • static Integer valueOf(int i):返回一个表示指定的int值的Integer实例

  • static Integer valueOf(String s):返回保存指定的String的值的Integer对象

  • static Integer valueOf(String s,int radix):返回一个Integer对象,该对象中保存了用第二个参数提供的基数进行解析时从指定的String中提取的值

  • static int parseInt(String s):将字符串参数作为有符号的十进制整数进行解析

  • static int parseInt(String s,int radix):使用第二个参数指定的基数,将字符串参数解析为有符号的整数

将包装类对象转换为基本类型的方式

  • int intValue():以int类型返回该Integer的值。

  • long longValue():以long类型返回该Integer的值。

总结

string 转换为基本数据类型
String → int     Integer.parseInt()
String → int     Integer.valueOf(str)
String → int     new Integer(string str)
String → double  Double.parseDouble()
String → byte     Byte.parseByte() 
String → char  没有Character.parseChar()不存在
    
基本类型转换为string类型
Int → String Integer.toString(int)
Double → String Double.toString(double);

Java5增加了自动装箱、拆箱机制,提供基本数据类型和包装类型的相互转换操作。

自动装箱

自动装箱即自动将基本数据类型转换成包装类型,在 Java5 之前,要将基本数据类型转换成包装类型只能这样做,看下面的代码。

Integer i1 = new Integer(5);
Integer i2 = Integer.valueOf(5);

// 自动装箱
Integer i3 = 5;

以上 3 种都可以进行转换,但在 Java 5 之前第 3 种方法是编译失败的,第 3 种方法也正是现在的自动装箱功能。另外,第一种构造器方法也不推荐使用了,已经标为废弃了。

其实自动装箱的原理就是调用包装类的 valueOf 方法,如第 2 个方法中的 Integer.valueOf 方法。

自动拆箱

自动拆箱即自动将包装类型转换成基本数据类型,与自动装箱相反。

// 自动拆箱
int i4 = i3;
int i5 = i3.intValue();

继续上面的例子,把 i3 赋值给 i4 就是实现的自动拆箱功能,自动装箱的原理就是调用包装类的 xxValue 方法,如 i5 中的 Integer 的 intValue 方法。

自动装箱、拆箱不只是体现在以上的例子,在方法接收参数、对象设置参数时都能自动装箱拆箱。

包装类的缓存问题

整型、char类型所对应的包装类,在自动装箱时,对于-128~127之间的值会进行缓存处理,其目的是提高效率。

缓存处理的原理为:如果数据在-128~127这个区间,那么在类加载时就已经为该区间的每个数值创建了对象,并将这256个对象存放到一个名为cache的数组中。每当自动装箱过程发生时(或者手动调用valueOf()时),就会先判断数据是否在该区间,如果在则直接获取数组中对应的包装类对象的引用,如果不在该区间,则会通过new调用包装类的构造方法来创建对象。

Integer a = 10;
Integer b = 10;
System.out.println(a==b); //true

Integer类相关源码:

public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

Math类

java中java.lang下面的所有类都不需要引入,可以直接来使用。

工具类Math,内部的属性和方法都是静态的。

//jdk1.7的新特性,静态导入
import static java.lang.Math.*;
//*表示全部
public class MathTest {
    public static void main(String[] args) {
        System.out.println(min(2,5));//2
    }
}
public class Demo {
    /*
       自然对数:Math.E
      圆周率:Math.PI
      绝对值:Math.abs(-1.5)-->1.5
      把小数去掉整数加1      Math.ceil(12.1)-->13.0
      把小数位舍弃      Math.floor(12.9)-->12.0
      比较两个数的大小    Math.max(12.9, 27)-->27
      比较两个数的大小    Math.min(12.9, 27)-->12.9
      计算某个数的n次幂  Math.pow(3, 3)-->27.0
      四舍五入    Math.round(4.5)-->5
      开平方        Math.sqrt(16)-->4.0;
   */
    public static void main(String[] args){
        System.out.println(Math.E);//e  2.718281828459045
        System.out.println(Math.PI);//3.141592653589793

        int r1 = Math.abs(-1);
        System.out.println("绝对值是:"+r1);//绝对值是:1
        //取整
        double r2 = Math.ceil(1.8);
        System.out.println("ceil向上取整:"+r2);////ceil向上取整:2.0

        double r3 = Math.floor(1.8);
        System.out.println("floor向下取整:"+r3);//floor向下取整:1.0

        int r4 = Math.max(2,5);
        System.out.println("求最大值:"+r4);//求最大值:5

        int r5 = Math.min(2,5);
        System.out.println("求最小值:"+r5);//求最小值:2

        double r6 = Math.pow(3, 3);
        System.out.println("3的3次幂"+r6);//3的3次幂27.0

        long r7 = Math.round(1.6);
        System.out.println("四舍五入:"+r7);//四舍五入:2

        double r8 = Math.sqrt(16);
        System.out.println("开平方:"+r8);//开平方:4.0
    }
}

Math.random()

返回一个double值为正号,大于等于0.0 ,小于1.0 。返回的值是从该范围(大约)均匀分布而伪随机选择的。

System.out.println(Math.random());

System类

System类代表系统,系统级的很多属性和控制方法都放置在该类中。该类位于java.lang包。

1、成员变量

System类内部包含in、out和err三个成员变量,分别代表标准输入流(键盘输入),标准输出流(显示器)和标准错误输出流。

2、成员方法

System类中提供了一些系统级的操作方法:

(1)public static void arraycopy(Object src, int srcPos,Object dest, int destPos, int length):该方法的作用是数组拷贝,也就是将一个数组中的内容复制到另外一个数组中的指定位置,由于该方法是native方法,所以性能上比使用循环高效。

(2)public static long currentTimeMillis():该方法的作用是返回当前的计算机时间,时间的表达格式为当前计算机时间和GMT时间(格林威治时间)1970年1月1号0时0分0秒所差的毫秒数。

(3)public static void exit(int status):该方法的作用是退出程序。其中status的值为0代表正常退出,非零代表异常退出。使用该方法可以在图形界面编程中实现程序的退出功能等。

(4)public static void gc():该方法的作用是请求系统进行垃圾回收。至于系统是否立刻回收,则取决于系统中垃圾回收算法的实现以及系统执行时的情况。

(5)public static String getProperty(String key):该方法的作用是获得系统中属性名为key的属性对应的值。

  • java.version:Java运行时环境版本。

  • java.home:Java安装目录。

  • os.name:操作系统的名称。

  • os.version:操作系统的版本。

  • user.name:用户的账户名称。

  • user.home:用户的主目录。

  • user.dir:用户的当前工作目录。

Runtime类

Runtime类:每个Java应用程序都有一个Runtime类实例,使应用程序能够与其运行的环境相连接。

public class Test {
    public static void main(String[] args) throws IOException {
        //获取Java运行时相关的运行时对象
        Runtime rt = Runtime.getRuntime( );
        System.out.println("处理器数量:" + rt.availableProcessors()+"个");
        System.out.println("JVM总内存数: "+rt.totalMemory()+" byte");
        System.out.println("JVM空闲内存数: "+rt.freeMemory()+" byte");
        System.out.println("JVM可用最大内存数:"+rt.maxMemory()+" byte");

        //在单独的进程中执行指定的字符串命令
        rt.exec("notepad"); //打开记事本
    }
}
0

评论区