Java中的API

最新推荐文章于 2024-02-23 17:33:19 发布
最新推荐文章于 2024-02-23 17:33:19 发布
阅读量1.3k 收藏 6
点赞数 2
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_26016931/article/details/115530761
版权

常用API
1 谁的方法(哪个类的)
2 什么方法(静态还是成员)
3 功能是什么(这个方法能做什么)
4 入参(使用该方法需要传递什么参数)
5 出参(该方法返回值是什么)

String

String 是字符串类 , 在 java.lang.String , 所以使用不需要导包
底层就是一个char数组,所以字符串很多特性就是数组特性
数组特性 :
查询更改快,添加删除慢
长度一旦确定不可更改
字符串一旦确定 不能更改
为了提升字符串的效率,java提供了一个"缓存机制",字符串常量池
String是引用类型,那么字符串应该保存在堆内存中,而字符串确被保存在常量池中
在程序执行中,如果需要用到一个 字符串 (“abc”),会去字符串常量池中找,是否有abc,如果有 直接拿过来使用,没有就创建一个
在这里插入图片描述

package _01String;

public class String1 {

	public static void main(String[] args) {
		String s1="ab"+"c";
		String s2="abc";
		String s3="abc";
		//同一个常量池地址
		System.out.println(s1==s2);
		System.out.println(s3==s2);
		System.out.println(s3.equals(s2));
		//new的指向堆内存，堆内存中指向常量池的se
		String s4=new String("se");
		String s5=new String("se");
		System.out.println(s4==s5);
		System.out.println(s4.equals(s5));
		//
		String s6="ab";
		String s7="ab";
		System.out.println(s6==s7);
		String s8=new String("sf");
		String s9=new String("sf");
		System.out.println(s8==s9);
		System.out.println(s8.equals(s9));
	}
}

//结果：
true
true
true
false
true
true
false
true


package _01String;

public class String2 {

	public static void main(String[] args) {
		String[] arr={"a","b","c"};
		String tem="";
		//拼接完成 a,b,c,d, 这样拼接 会创建很多字符串对象,浪费空间,效率低
		// 因为并不是在原有空间进行更改,而是新建
		for(String string : arr){
			tem+=string+",";
		}
		System.out.println(tem);
		System.out.println(tem.length());
		//
		String[] a={"b","c","d"};
		String tem1="";
		for(String str:a){
			tem1+=str+".";
		}
		System.out.println(tem1);
	}
}

//结果：
a,b,c,
6
b.c.d.


package _01String;

/*
 * 如果是 String s2 = "a"+"b"; 在编译阶段 就等于是ab就会把 + 去掉
 * 
 * 但是如果是变量相加 String s3 = a+b;    
 * String s4 = "a"+new String("b"); 是运行时进行操作的
 * 	在运行时会创建一个StringBuffer对象,把两个字符串拼接到一起,
 * 然后转换为String,而此时 s3和s4 分别指向不同的堆内存空间
 * 这种情况再比较的时候,只能使用equals
 * 
 */
public class String5 {

	public static void main(String[] args) {
		String s1 = "ab";
		// 这种字面量相加,在编译阶段,就把+ 去掉了,等于 ab
		String s2 = "a" + "b";
		String a="a";
		String b="b";
		String s3=a+b;
		String s4="a"+new String("b");
		System.out.println(s2==s3);
		System.out.println(s2==s4);
		System.out.println(s2==s1);
	}
}
//
false
false
true

StringBuffer和StringBuilder

package _01String;
/* java.lang.String
 * java.lang.StringBuffer
 * java.lang.StringBuilder 
 * 1 String 是不可变的字符串,一旦确定 长度不能更改,所以不适合做拼接操作
 * 2 StringBuffer和StringBuilder 是可变的字符串缓冲区,适合做拼接操作
 * 原理 : 预先在内存中申请一块空间,用来容纳更多的字符(字符数组)
 *	如果预留空间不够 会自动扩容,默认容量是16个字符
 * 
 * 3 StringBuffer和StringBuilder的区别
 *StringBuffer 线程安全,多线程环境下,没有问题,所以经常用于类中
 *StringBuilder 非线程安全,多线程环境下,可能有问题,所以经常用于方法中
 * 
 */
public class String6 {

	public static void main(String[] args) {
		//创建对象
		StringBuilder sb=new StringBuilder();
		//添加
		sb.append("a");
		sb.append("b");
		//插入指定位置
		sb.insert(2, "c");
		System.out.println(sb.length());
		System.out.println(sb);
		//返回当前的容量value.length。默认是16,
		//容量是新插入字符的可用存储量，否则将进行分配。
		System.out.println(sb.capacity());
		//转换为字符串
		String s=sb.toString();
		System.out.println(s);
		// 反转
		System.out.println(sb.reverse());
	}
}
//结果：
3
abc
16
abc
cba


package _01String;

public class String4 {
public static void main(String[] args){
	//获取字符串某个位置的字
	String s1="asdfgh";
	char c1=s1.charAt(2);
	System.out.println(c1);
	
	//返回长度
	int l=s1.length();
	System.out.println(l);
	
	//判断字符串是否以指定字符串结束
	//是否以指定字符开始
	System.out.println("asddfdsf".endsWith("f"));
	System.out.println("afsdfadsf".startsWith("afs"));
	
	//比较两个字符串是否相等
	System.out.println("ads".equals("Ads"));
	System.out.println("ads".equalsIgnoreCase("Ads"));
	
	//把字符串转换为字节数组
	byte[] bytes="Abc".getBytes();
	for(byte a:bytes){
		System.out.println(a);
	}
	
	//获取指定字符串的起始索引下标,找不到返回 -1
	System.out.println("adfdfsadfbc".indexOf("d"));
	//获取最后一次出现的索引,找不到返回 -1
	System.out.println("adfdfsadfbc".lastIndexOf("d"));
	//在指定位置开始找,第一次出现的索引,找不到返回-1
	System.out.println("asfuox".indexOf("o", 4));
	System.out.println("asfuox".lastIndexOf("o", 5));
	
	// 把符合条件的字符用指定字符替换(不支持正则表达式)
	System.out.println("ffdagdgdffdsae".replace("f", "."));
	// 把符合条件的字符用指定字符替换(支持正则表达式)
	System.out.println("fFfdagdgdffdsae".replaceAll("f", "."));
	
	// 分割字符串,需要指定分隔符,支持正则表达式
	String time="13331,111,22";
	String[] s=time.split(",");
	for(String a:s){
		System.out.println(a);
	}
	
	//获取该字符串的子字符串(下标是起始位置,包含)
	System.out.println("afdadf".substring(2));
	// 截取字符串,开始位置(包含) 结束位置(不包含)
	System.out.println("afdadf".subSequence(1, 4));
	
	// 把字符串转换为char数组
	char[] chars="acva".toCharArray();
	for(char c:chars){
		System.out.println(c);
	}
	//转大写和小写
	System.out.println("asdf".toUpperCase());
	System.out.println("asdf".toUpperCase().toLowerCase());
	//两边去空格
	System.out.println("   x sdffsd   ".trim());
	
	// 调用对象的toString方法,并解决空指针异常
	Object obj=null;
	//obj.toString();
	System.out.println(obj);
}
}

//
d
6
true
true
false
true
65
98
99
1
7
4
4
..dagdgd..dsae
.F.dagdgd..dsae
13331
111
22
dadf
fda
a
c
v
a
ASDF
asdf
x sdffsd
null


package _01String;

public class String3 {

	public static void main(String[] args) {
		String s1="abc";
		String s2=new String("abd");
		//字节数组转字符串
		byte[] bytes={97,98,99,100};
		String s3=new String(bytes);
		System.out.println(s3);
		
		//字节数组中一部分转换为字符串
		//从下表1开始取两个
		String s4=new String(bytes,2,2);
		System.out.println(s4);
		//char数组转字符串
		char[] chars={'a','c','c','d','e'};
		String s5=new String(chars);
		System.out.println(s5);
		//截取部分
		String s6=new String(chars,3,2);
		System.out.println(s6);
	}
}

//
abcd
cd
accde
de

Integer

在这里插入图片描述

package _02Integer;
/* 包装类 : 封装了基本数据类型的一些操作,更加方便使用,更加面向对象
 * 		byte 		 java.lang.Byte
 * 		short 	 java.lang.Short
 * 		int  		 java.lang.Integer
 * 		long	     java.lang.Long
 * 		float      java.lang.Float
 * 		double  java.lang.Double
 * 		boolean  java.lang.Boolean
 * 		char       java.lang.Character
 * 要求 一个方法的参数列表可以接收任何数据类型
 *Object
 *所有类都可以转型为Object类型,但是基本数据类型呢? 可以转换为对应的封装类,
 *然后封装类再向上转型为Object即可
 * 
 */
public class Integer1 {

	public static void main(String[] args) {
		// 基本类型
		byte b=127;
		// 引用类型,包装类
		Byte b1=new Byte(b);
		m1(b1);
	}
	public static void m1(Object o){
		System.out.println(o);
	}
}

//
127

基本使用

package _02Integer;

public class Integer2 {

	public static void main(String[] args) {
		System.out.println(Integer.MAX_VALUE);
		System.out.println(Short.MIN_VALUE);
		System.out.println(Byte.MAX_VALUE);
		System.out.println(Long.MAX_VALUE);
		
		// 创建包装类对象
		// int --> Integer
		Integer i1=new Integer(10);
		// String --> Integer 必须是纯数字的字符串,小数点也不能有
		Integer i2=new Integer("1000");
		System.out.println(i1);
		System.out.println(i2);
	}
}

//
2147483647
-32768
127
9223372036854775807
10
1000

常用方法

package _02Integer;

public class Integer3 {

	public static void main(String[] args) {
		Integer i1=new Integer(22);
		Integer i3=Integer.valueOf(12);
		Integer i4=Integer.valueOf("134");
		
		int i2=i1.intValue();
		
		//3 static int parseInt(String s) : String --> int 必须是纯数字的字符串
		int age=Integer.parseInt("233");
		//转double
		double s=Double.parseDouble("23.3");
		
		//转二进制显示格式
		String s1=Integer.toBinaryString(4);
		System.out.println(s1);
		//转换为八进制显示格式
		System.out.println(Integer.toOctalString(10));
		//转换为十六进制显示格式
		System.out.println(Integer.toHexString(15));
	}
}

//
100
12
f

类型转换

package _02Integer;
/**
 * int , Integer , String 三种类型相互转换
 * @author moon
 */
public class Integer4 {

	public static void main(String[] args) {
		//1 int -Integer
		Integer i1=Integer.valueOf(20);
		//2 Integer-int
		int i2=i1.intValue();
		//3 String -Integer
		Integer i3=Integer.valueOf("23");
		//4 Integer-String 
		String s1=i3.toString();
		//5 int-String 
		String s2=10+"";
		//6 String -int 
		int i4=Integer.parseInt(s2);
	}
}

自动装箱/自动拆箱

package _02Integer;

/*
 java1.5开始新特性
 *自动装箱
 *把 基本类型 自动转换为 封装类类型
 *自动拆箱
 *把 封装类类型 自动转换为 基本类型
 * 装箱和拆箱都是编译时处理的
 */
public class Integer5 {

	public static void main(String[] args) {
		// 1.5之前
		// int-Integer
		Integer i1 = new Integer(10);
		// Integer-int
		int i2 = i1.intValue();

		// 1.5开始
		// int -Integer
		Integer i3 = 10;
		// Integer-int
		int i4 = i3;
		// 此时 2 会先自动装箱,然后向上转型为Object
		m1(2);

		Integer i5 = 20;
		Integer i6 = 12;
		// 先自动拆箱为int类型,再相减
		System.out.println(i5 + i6);
		m1(i5 - i6);
	}

	public static void m1(Object o) {
		System.out.println(o);
	}
}

//
2
32
8

在这里插入图片描述

整型常量池

package _02Integer;
/*
 * 深入理解自动装箱和拆箱
 * 1 都是编译时概念,和运行时无关
 * 2 装箱 会自动转换为 Integer.valueOf(xx)
 * 3 拆箱 会自动转换为 i1.intValue()
 * 八种包装类 和 String 都覆写了 toString 还有 equals , hashCode方法
 * Integer.valueOf : 基本类型转换为Integer类型,
 * 并且里面初始化了一个整型常量池
 */
public class Integer6 {

	public static void main(String[] args) {
		// 编译之后 是这样 Integer i1 = Integer.valueOf(10); 
		//符合范围 就是要 提前准备好的对象
		Integer i1=10;
		Integer i2=10;
		System.out.println(i1==i2);
		// 编译之后 是这样  Integer i1 = Integer.valueOf(128); 
		//相当于  Integer i1 =  new Integer(128);
		i1=128;
		i2=128;
		System.out.println(i1 == i2);
		// true, 因为覆写了equals方法
		System.out.println(i1.equals(i2));
	}
}

//
true
false
true

System
System类提供的public static long currentTimeMillis()用来返回当前时 间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。
此方法适于计算时间差。
System类代表系统，系统级的很多属性和控制方法都放置在该类的内部。 该类位于java.lang包。
由于该类的构造器是private的，所以无法创建该类的对象，也就是无法实 例化该类。其内部的成员变量和成员方法都是static的，所以也可以很方便 的进行调用。
成员变量
System类内部包含in、out和err三个成员变量，分别代表标准输入流
(键盘输入)，标准输出流(显示器)和标准错误输出流(显示器)。
成员方法
native long currentTimeMillis()：
该方法的作用是返回当前的计算机时间，时间的表达格式为当前计算机时
间和GMT时间(格林威治时间)1970年1月1号0时0分0秒所差的毫秒数。
void exit(int status)：
该方法的作用是退出程序。其中status的值为0代表正常退出，非零代表
异常退出。使用该方法可以在图形界面编程中实现程序的退出功能等。

Date
构造方法
无参 有参
Date() : 获取当前系统时间
Date(long) : 获取时间原点到指定毫秒数的时间

基本使用

package _03Data;

import java.util.Date;

public class Data1 {

	public static void main(String[] args) {
		// 获取时间原点到当前系统时间的毫秒数
		long now=System.currentTimeMillis();
		System.out.println(now);
		Date t=new Date();
		System.out.println(t);
	}
}

//
1617886722508
Thu Apr 08 20:58:42 CST 2021

时间格式化

package _03Data;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Data2 {

	public static void main(String[] args) throws ParseException {
		//创建当前系统时间
		Date t=new Date();
		System.out.println(t);
		
		// 时间原点到指定毫秒数的时间
		Date t1=new Date(2000);
		System.out.println(t1);
		
		//年月日 时分秒 毫秒 yMd Hms S
		// 创建时间格式化对象
		SimpleDateFormat sdf=new SimpleDateFormat("yyyy/MM/dd HH:mm:ss SSS");
		//将时间t格式化
		String str=sdf.format(t);
		System.out.println(str);
		// String类型的时间,转换为Date 类型 ,
		//string类型的时间格式 必须和sdf指定的格式一致
		Date t2=sdf.parse(str);
		System.out.println(t2);
	}
}

//
Thu Apr 08 20:59:12 CST 2021
Thu Jan 01 08:00:02 CST 1970
2021/04/08 20:59:12 518
Thu Apr 08 20:59:12 CST 2021


package _03Data;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Date3 {

	public static void main(String[] args) {
	//时间里的分钟减少10：
		SimpleDateFormat sdf = new SimpleDateFormat("HH:mm");
		Date date = new Date();
		String time = sdf.format(date);
		String[] times = time.split(":");
		int h = Integer.parseInt(times[0]);
		int m = Integer.parseInt(times[1])-10;
		if (m < 0) {
			h--;
			m += 60;		
		}
		System.out.println(h + ":" + m);

		// 获取当前时间毫秒数
		long currentTimeMillis = System.currentTimeMillis();
		// 减去10分钟的毫秒数
		currentTimeMillis = currentTimeMillis - 1000 * 60 * 10;
		// 创建时间对象
		SimpleDateFormat dds=new SimpleDateFormat("yyyy/MM/dd HH:mm:ss SSS");
		Date t=new Date(currentTimeMillis);
		String str=dds.format(t);
		System.out.println(str);
	}
}

//
20:49
2021/04/08 20:49:43 023
今天十五
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
Java——API
qq_51733711的博客
08-30 553
javaAPI文档
java中文api
04-05
中文API 。
Java API
Gnimlew的博客
08-12 4180
API（Application Programming Interface,应用程序编程接口）是一些预先定义的函数，目的是提供应用程序与开发人员基于某软件或硬件的以访问一组例程的能力，而又无需访问源码，或理解内部工作机制的细节。......
【Java常用API】
Requests
03-20 253
`-```day03 【常用API】 今日内容 权限修饰符 分类 权限 代码块(格式,位置,执行,使用场景) 构造代码块 静态代码块 局部代码块 Object类 时间日期类 Math类(静态方法) System类(静态方法) BigInteger类 BigDecimal类 Arrays类 包装类 第一章 权限修饰符 1.1 权限修饰符 概述 在java中提供了4个权限修饰符,使用不同的权限修饰符修饰,被修饰的内容就具有不同的访问权限 分类: public : 公共的 protecte
JAVA---API
qq_56797899的博客
02-04 2381
Java--API
Java常用API
最新发布
是程序喵呀
02-23 2491
别人写好的一些程序，给咱们程序员直接拿去调用。Java官方其实已经给我们写好了很多很多类，每一个类中又提供了一系列方法来解决与这个类相关的问题。比如String类，表示字符串，提供的方法全都是对字符串操作的。比如ArrayList类，表示一个容器，提供的方法都是对容器中的数据进行操作的。像这样的类还有很多，Java把这些类是干什么用的、类中的每一个方法是什么含义，编写成了文档，我们把这个文档称之为API文档。1. 我们为什么要学习别人写好的程序呢？在行业中有这么一句话：“不要重复造轮子”。
java中文API
02-23
2. **集合框架**：Java集合框架是Java API中非常重要的一部分，它包括List（如ArrayList和LinkedList）、Set（如HashSet和TreeSet）和Map（如HashMap和TreeMap）等接口和实现类，为数据存储和处理提供了强大的支持。...
80.java中API.zip
06-16
80.java中API.zip80.java中API.zip80.java中API.zip80.java中API.zip80.java中API.zip80.java中API.zip80.java中API.zip80.java中API.zip80.java中API.zip80.java中API.zip80.java中API.zip80.java中API.zip80.java...
JAVA中文API亲测可用
08-01
在提供的压缩包文件名称"JAVAAPI.chm"中，".chm"是一种Microsoft编写的帮助文件格式，用于存放HTML文档和相关索引，常用于软件的联机帮助文档。这意味着这个Java 1.7中文API文档是以离线CHM形式存在的，用户可以在...
java中的API
zjd934784273的专栏
06-11 542
------- android培训、java培训、期待与您交流！ ---------- String类： 字符串是一个特殊的对象，字符串最大的一个特点就是：字符串一旦被初始化就不可以改变 例如 s1="abc" s2="abc",这两个对象指的是同一个，也就是说s1==s2返回true，将"abc"放在常量池中 对于String str="abc"和String str1=new Str
Java中的各种API
02-10
Java中的各种API Struts1.2_api.chm Spring_api_zh_CN.chm Hibernate3.2_api.chm
java_Api
03-17
NULL 博文链接：https://zlemo1984.iteye.com/blog/505193
java的api介绍
12-22
java开发离不开api文档，整理分享，需要xmind才能打开
Java中常用的API总结
热门推荐
始于足下的专栏
08-18 2万+
Java API是JDK所提供的使用类，这些类将底层的代码给封装起来了。Object类是java语言中的根类，它所描述的所有方法子类都可以使用，所有类在创建对象的时候，最终找的父类就是Object。在Objec类中，最常见的就是euqals方法和toString方法。equals方法用于比较两个对象是否相同，实质是比较两个对象的内存地址。在复写Object中的equals方法时，一定要注意publ...
Java的api
yibashou的博客
06-16 640
假设控制机器人怎么样踢足球、，需要向机器人发出向前跑、向后跑、射门，抢球。知道机器人厂商一定会提供一些用于控制机器人的Java的类就是机器人，这些类的中定义好操作机器人各种的动作的方法，其实这些Java的类就是机器人的厂商提供给应用程序编程序打的接口，大家把这些类称为xxx  robot API（意思就是xxx厂家的机器人API）1、string类和stringbuffer类在操作string类之...
JAVA-常用API
xiaosongshi的博客
01-06 1689
第一节 Scanner类 1.1 API概述
JAVA常用API
tuoniaoxs的博客
06-06 1万+
Java常用API String、StringBuilder、Math、System、Object、Objects、BigDecimal等
javaAPI
qq_37636695的博客
11-22 297
API——运用程序本地接口 Object类的成员方法 （Java.lang.object） public int hashCode()          返回对象的哈希码值。哈希值是根据哈希算法计算出来的一个值，这个值和地址有关，但不是实际地址。 public final Class getClass()         返回一个class对象，可以根据这个class对象下面的publi...
Java中API的作用
05-25
Java中的API（Application Programming Interface）是一组已经封装好的类、接口、方法等，供开发者在应用程序中使用。 API的作用主要有以下几点： 1. 提供标准接口：API提供了标准接口，使得开发人员可以在自己的应用程序中使用这些接口，从而简化开发流程，减少代码量，提高开发效率。 2. 降低复杂度：API将复杂的底层操作封装起来，开发人员可以直接调用API中的方法实现想要的功能，而无需深入了解底层实现细节。 3. 提高可维护性：由于API封装了底层实现细节，因此开发人员可以更容易地修改和维护代码。 4. 提高可重用性：API提供了一组标准接口，使得开发人员可以在不同的应用程序中重复使用相同的代码，从而提高代码的可重用性。 总之，API是Java开发中非常重要的一部分，它为开发人员提供了一组标准接口，使得开发人员可以快速、方便地实现想要的功能。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值