第三阶段API
作者：互联网
第三阶段:API
一:查看API需要重点看的地方
1.看包
2.看解释说明
3.看构造
4.看方法:看方法的解释说明,再看修饰符,然后返回值,再看是否需要穿参以及参数类型
在java中hashcode默认返回值是十进制的地址值
equals 使用的时候 比较引用类型的时候,比较的是地址值
如果你想比较具体的值,需要自己对equals方法进行重写
如何重写:
source------hashcodeAndequals方法
其实很多类里面都对equals方法进行重写操作
比较基本类型,比较的是值是否相同
比较引用类型,比较的是地址值是否相同
二.Object:
protected Object clone() 深克隆:副本的影响不回对主题造成影响
浅克隆:副本即本体,副本改变,本体改变 完完全全复制一个新的对象出来
创建并返回此对象的一个副本
boolean equals(Object obj)*****只是其他某个对象是否与此对象"相等"
protected void finalize()***当垃圾回收器确定不存在对该对象的更多应用时,有对象的垃圾回收器调用此方法.
Class<?>getClass()*** 反射 返回此object 的运行是类.
int hashcode()*** 返回该对象的哈希码值.
String toString() ********* 返回该对象的字符串表示.
public class Demo1 implements Cloneable{
String name;
String age;
public Demo1(String name, String age) {
super();
this.name = name;
this.age = age;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((age == null) ? 0 : age.hashCode());
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Demo1 other = (Demo1) obj;
if (age == null) {
if (other.age != null)
return false;
} else if (!age.equals(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 String toString() {
return "姓名=" + name + ", 年龄=" + age ;
}
public static void main(String[] args) throws CloneNotSupportedException {
Demo1 demo1 = new Demo1("huguanyu","30");
Demo1 demo2 = new Demo1("huguanyu","30");
Demo1 d1 = demo1;
Object obj = demo1.clone();
Demo1 d2 = (Demo1)obj;
System.out.println(demo1.name);
System.out.println(d1.name);
System.out.println(d2.name);
String s1 = new String("helloworld");
String s2 = "helloworld";
System.out.println(demo1 == demo2);
System.out.println(demo1.equals(demo2));
System.out.println("----------------------------");
System.out.println(s1 == s2);//false
System.out.println(s1.equals(s2));//true
System.out.println(demo1.hashCode());
System.out.println(demo1);
}
}
boolean equals (object obj) 比较字符串的字符序列
boolean equals IgnorCase(String str) 比较字符串序列,不关心大小写
loolean contains(String str) 是否包含某个字符串
boolean startsWith(String str) 以…开头
boolean endWith(String str) 以…结尾
String concat(String s) 将指定字符串添加到另一个串的末尾
boolean is Empty 判断是否为空
int length() 获取字符串长度
char charAt(int index ) 根据角标求该角标对应的字符
int index of(String str) 根据字符求索引值
String substring (int start ) 截取字符串
String substring (int start ,int end)截取字符串 从start开始到end结束
/*
* 3.模拟登录,给三次机会,并提示还有几次机会
* 1.假设用户名和密码均为admin，
* 如果输入正确，控制台输出：欢迎admin登录
* 如果输入错误，控制台输出：录入错误,
* 您还有2次机会（最多有3次机会）
*/
public class text10 {
public static void main(String[] args) {
String name="admin";
String password="admin";
for (int i = 1; i <4; i++) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入您的用户名");
String user=sc.next();
System.out.println("请输入您的密码");
String password1=sc.next();
if (name.equals(user)&&password.equals(password1)) {
System.out.println("欢迎admin登录");
}else {
System.out.println("您还有"+(3-i)+"次机会");
}
}
}
}
String s = “abcJJLKjlkJLKJ89HKJhhHJ789HJ889H”;
课堂练习：
1：遍历获取字符串中的每一个字符
2：统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)
*/
public class Demo4 {
public static void main(String[] args) {
String s1 = "woaijavawofeichangaijavagun";
System.out.println(s1.length());
char ch = s1.charAt(5);
System.out.println(ch);
int i = s1.indexOf("java");
System.out.println(i);
System.out.println(s1.substring(5));
System.out.println(s1);
System.out.println(s1.substring(5, 10));
}
}
/*2.键盘录入一个字符串，统计该字符串中大写字母字符，小写字母字符，数字字符出现的次数,其他字符出现的次数。
* 例如键盘录入：ABCDEabcd123456!@#$%^
* 输出：ABCDEabcd123456!@#$%^中大写字母有:5个,小写字母有:4个,数字字符:6个,其他字符:6个
*
*/
public class text9 {
public static void main(String[] args) {
String s="ABCDEabcd123456!@#$%^";
int upper=0;
int lower=0;
int num=0;
int character=0;
System.out.println(s);
for (int i = 0; i < s.length(); i++) {
if (s.charAt(i)>='a'&&s.charAt(i)<='z') {
lower++;
}
if (s.charAt(i)>='A'&&s.charAt(i)<='Z') {
upper++;
}
if (s.charAt(i)>='0'&&s.charAt(i)<='9') {
num++;
}if (s.charAt(i)=='!'||s.charAt(i)=='@'||s.charAt(i)=='#'||s.charAt(i)=='$'||s.charAt(i)=='%'||s.charAt(i)=='^') {
character++;
}
}
System.out.println("有大写字母"+lower+"个数");
System.out.println("有小写字母"+upper+"个数");
System.out.println("有数字"+num+"个数");
System.out.println("有其他符号"+character+"个数");
}
}
package com._51doit.demo;
/*
*
*
* byte[] getBytes() 将字符串转换为byte数组
char[] toCharArray() 将字符串转换为char数组
static String valueOf(int i) 将int类型的数字转换为String
String toLowerCase() 将字符串变为小写
String toUpperCase() 将字符串变为大写
String concat(String str) 将括号中的字符串拼接到调用者身上 拼接到屁股上
Object这个类统治了整个java
但是唯有基本类型他没有统治
但是java公司为了巩固他的权力
给基本类型分别定义了一个引用类型包装类
所以Object间接的又把基本类型统治了
课堂练习：把一个
字符串的首字母转成大写，其余为小写。(只考虑英文大小写字母字符)
编写程序将+“jdk”+全部变为大写并输出到屏幕%截取子串”DK”+并输出到屏幕
*
*/
public class Demo6 {
public static void main(String[] args) {
String ss = "hellojianguo";
byte[] bytes = ss.getBytes();
char[] ch = ss.toCharArray();
System.out.println(bytes);
for (int i = 0; i < bytes.length; i++) {
System.out.print((char)bytes[i]);
}
System.out.println();
System.out.println("===========================");
for (int i = 0; i < ch.length; i++) {
System.out.print(ch[i]);
}
System.out.println();
System.out.println("===========================");
System.out.println(String.valueOf(true));
String sss = ss.toUpperCase();
System.out.println(sss);
System.out.println(sss.toLowerCase());
System.out.println(ss.concat("好好学习,天天向上,争取拿到20K"));
}
}
替换功能
String replace(char old,char new)
String replace(String old,String new)
去除字符串头尾空格
String trim() 只能去除头和尾的空格
按字典顺序比较两个字符串
int compareTo(String str)
从头到尾依次做相减操作,会将每个位置上的字符转换为int类型的数字然后进行相减
如果位数不一样的情况下,但是从多余开始前面的元素都一样,那么返回值就是
多出来几位 返回几
int compareToIgnoreCase(String str)
切割
String[] split(String regex)
根据给定正则表达式的匹配拆分此字符串。
*/
public class Demo8 {
public static void main(String[] args) {
String ss = "helloworld";
System.out.println(ss.replace('l', 'L'));
System.out.println(ss);
System.out.println(ss.replace("world", "hadoop"));
String s = " hello java world ";
System.out.println(s.trim());
String s1 = "huguanyu";
String s2 = "huguanyuha";
int i = s1.compareTo(s2);
System.out.println(i);
String sss = "woaijavawoshifenaijavaniaimawobuaijavagun";
String[] sp = sss.split("java");
for (int j = 0; j < sp.length; j++) {
System.out.print(sp[j]+" ");
}
}
}
tringBuffer:线程安全的可变字符序列 字符串容器 可变的字符串 慢
* StringBuilder:一个可变的字符序列 线程不安全 快
* String:不可变的字符序列
*
*
* 添加功能
public StringBuffer append(String str)
public StringBuffer insert(int offset,String str)
删除功能
public StringBuffer deleteCharAt(int index)
public StringBuffer delete(int start,int end) 半开区间 包头不包尾
替换功能
public StringBuffer replace(int start,int end,String str)
反转功能
public StringBuffer reverse()
*
* 写一个方法判断字符串是否对称
*
*/
public class Demo9 {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer("helloworld");
System.out.println(sb);
System.out.println(sb.append("javaissoeasy"));
System.out.println(sb);
System.out.println(sb.insert(0, "woshidashazi"));
System.out.println(sb);
System.out.println(sb.deleteCharAt(0));
System.out.println(sb.delete(0, 5));
System.out.println(sb.replace(0, 5, "jiaochentao"));
System.out.println(sb.reverse());
System.out.println(sb.substring(0, 10));
System.out.println(sb);
// 链式编程
StringBuffer sb2 = new StringBuffer("a");
System.out.println(sb2.append("b").append("c").append("d"));
}
}
三.数组的高级应用
选择排序:外层控制轮,内层控制次数
格式:for (int i=0;i<arr.length-1;i++;){
for(int j=i+1;j<arr.length;j++;){
if(arr[i]>arr[j]){
int temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}
}
public static void main(String[] args) {
// 这是选择排序
// Scanner sc=new Scanner(System.in);
// System.out.println("请输入一个数组");
// int a=sc.nextInt();
// int []arr={};
int[] arr = { 89, 98, 12, 56, 99, 100, 65 };
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - i - 1; j++) {
if (arr[i] > arr[j]) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
if (arr[i] < arr[j]) {
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
System.out.println(Arrays.toString(arr));
}
}
冒泡排序
格式:for (int i=0;i<arr.length-1;i++;){
for(int j=i+1;j<arr.length-i-1;j++;){
if(arr[j]>arr[j]+1){
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
// 这是冒泡排序
int[] arr1 = { 89, 98, 12, 56, 99, 100, 65 };
for (int i1 = 0; i1 < arr.length - 1; i1++) {
for (int j1 = 0; j1 < arr.length - i1 - 1; j1++) {
if (arr[j1] > arr[j1 + 1]) {
int temp = arr[j1];
arr[j1] = arr[j1 + 1];
arr[j1 + 1] = temp;
}
}
}
System.out.println(Arrays.toString(arr));
折半查找:需要事先定义一个最大值,一个最小值,一个中间值
如果我们要查找的数,比中间值大,那就证明中间值之前的没用了
所以我们让最小值改变到中间值的角标+1的位置
/**
* 二分查找
* @param arr
* @param key
*/
public static void binarySearch(int[] arr, int key) {
int max = arr.length -1;
int min = 0;
int middle = (max + min)/2;
while (min < max) {
if (arr[middle] == key) {
System.out.println(middle);
return;
}else if (key > arr[middle]) {
min = middle + 1;
}else if (key < arr[middle]) {
max = middle - 1;
}
middle = (min + max) / 2;
}
System.out.println("不存在此数字");
}
}
/**
* public static String toString(int[] a)
public static void sort(int[] a) 此排序默认升序 不会做降序排序
public static int binarySearch(int[] a,int key) 二分查找 只能查升序
*
*/
public class Demo5 {
public static void main(String[] args) {
int[] arr = {5,10,16,78,95,100};
int key = 10;
ArrayUtil.binarySearch(arr,key);
int[] arr1 = {10,9,8,7,6,5,4};
System.out.println(Arrays.binarySearch(arr, 10));
System.out.println(Arrays.binarySearch(arr1, 10));
int[] arr2 = {5,6,7,4,2,3,1,97};
Arrays.sort(arr2);
System.out.println(Arrays.toString(arr2));
}
}
/*
* 基本类型包装类
* Object 基类 超类 万类之祖
* 他统治了所有的引用类型 但是就把八大基本类型给抛弃了
* 后来为了加强帝王的统治 给基本类升成了包装类
* byte Byte
* short Short
* int Integer
* long Long
* float Float
* double Double
* char Character
* boolean Boolean
*
* 基本类型包装类:用于基本数据类型与字符串之间的转换
*
* 八大基本类型包装类 操作的都是基本类型和基本类型组成的字符串
*
* 构造方法:
* Integer(int value)
构造一个新分配的 Integer 对象，它表示指定的 int 值。
Integer(String s)
构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。
此处的String中必须全部为数字
*
* JDK1.5以后 java给所有的包装类提供了方便
* 提供了一个叫做自动拆箱操作
* 出了自动拆箱以外 还有自动装箱
*
* 成员方法
* int类型和String类型的相互转换
int – String：直接相加空字符串
String – int：public static int parseInt(String s)
*
*
* 常用的基本进制转换
public static String toBinaryString(int i) 转成二进制
public static String toOctalString(int i) 转成八进制
public static String toHexString(int i) 转16进制
十进制到其他进制
public static String toString(int i,int radix) 十进制到任何进制
最低二进制 最高36进制
static String toString(int i)
返回一个表示指定整数的 String 对象。
其他进制到十进制
public static int parseInt(String s,int radix)
第一个参数代表你要转换的数字字符串
第二个参数是告诉系统 你前面的字符串属于什么类型
*
*
*
*
*
*/
public class Demo6 {
public static void main(String[] args) {
Integer in = new Integer(10);
System.out.println(in);
Integer in1 = new Integer("123456");
System.out.println(in1);
int i =20;
Integer integer = new Integer(i);
// 为什么可以运行成功 因为在此处做了自动拆箱操作
i = integer + i;
System.out.println(i);
// 这种写法就是自动装箱操作
Integer in2 = 100;
String ss = in2 + "1234";
System.out.println(Integer.parseInt(ss));
String bs = Integer.toBinaryString(80);
System.out.println(bs);
String os = Integer.toOctalString(80);
System.out.println(os);
String ohx = Integer.toHexString(80);
System.out.println(ohx);
String str = Integer.toString(100, 2);
System.out.println(str);
System.out.println(Integer.toString(20));
System.out.println(Integer.parseInt("64", 8));
}
}
/*
*
* Character类概述
Character 类在对象中包装一个基本类型 char 的值
此外，该类提供了几种方法，以确定字符的类别（小写字母，数字，等等），并将字符从大写转换成小写，反之亦然
构造方法
public Character(char value)
*
*
* 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 Demo7 {
public static void main(String[] args) {
Character ch = 'A';
// String s = “JKLhHKKjhkHKJHkgk*(n^*&6788)()9090JJLLJhbjkkljl”;
// 统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串");
String line = sc.next();
int upper = 0;
int lower = 0;
int num = 0;
for (int i = 0; i < line.length(); i++) {
if (Character.isUpperCase(line.charAt(i))) {
upper++;
}else if (Character.isLowerCase(line.charAt(i))) {
lower++;
}else if (Character.isDigit(line.charAt(i))) {
num++;
}
}
System.out.println("大写字母有"+upper);
System.out.println("小写字母有"+lower);
System.out.println("数字有"+num);
}
}
// 将s首字母变成小写 其他字母变成大写 然后输出
public static void main(String[] args) {
String s="Guodingding";
String s1=s.substring(0, 1);
String s2=s.substring(1);
StringBuffer sb =new StringBuffer(s1.toLowerCase()).append(s2.toUpperCase());
System.out.println(sb);
System.out.println();
System.out.println("=============");
StringBuilder sb1=new StringBuilder();
for (int i = 0; i < s.length(); i++) {
if (i==0) {
sb1.append(Character.toLowerCase(s.charAt(i)));
}else {
sb1.append(Character.toUpperCase(s.charAt(i)));
}
}
System.out.println(sb1);
}
//public BigInteger(String val)
//public BigInteger add(BigInteger val) 加法 add
//public BigInteger subtract(BigInteger val) 减法 sub
//public BigInteger multiply(BigInteger val) 乘法 mutli
//public BigInteger divide(BigInteger val) 除法 div
//public BigInteger[] divideAndRemainder(BigInteger val) 除法和取余
public class Demo9 {
public static void main(String[] args) {
BigInteger bi = new BigInteger("123456789");
System.out.println(bi);
System.out.println(bi.add(new BigInteger("10000000000000000")));
System.out.println(bi.subtract(new BigInteger("10000000000000000")));
System.out.println(bi.multiply(new BigInteger("10000000000000000")));
System.out.println(bi.divide(new BigInteger("10000000000000000")));
BigInteger[] ddr = bi.divideAndRemainder(new BigInteger("10000000000000000"));
System.out.println(Arrays.toString(ddr));
}
}
//public BigDecimal add(BigDecimal augend) 加法
//public BigDecimal subtract(BigDecimal subtrahend) 减法
//public BigDecimal multiply(BigDecimal multiplicand) 乘法
//public BigDecimal divide(BigDecimal divisor) 除法
//public BigDecimal divide(BigDecimal divisor,int scale, int roundingMode)
public class Demo10 {
public static void main(String[] args) {
// System.out.println(0.08 + 0.02);
// System.out.println(1.0 - 0.32);
// System.out.println(1.013 * 100);
// System.out.println(1.201 / 100);
BigDecimal bdc = new BigDecimal("1.0");
System.out.println(bdc);
BigDecimal bdc2 = new BigDecimal("0.32");
System.out.println(bdc2);
System.out.println(bdc.add(bdc2));
System.out.println(bdc.subtract(bdc2));
}
}
//public static int abs(int a) 求绝对值
//public static double ceil(double a) 向上取整
//public static double floor(double a) 向下取整
//public static double pow(double a,double b) a的b次方
//public static double random() 随机数 0.0 - 1.0
//public static int round(float a) 参数为double的自学 四舍五入
//public static double sqrt(double a) 平方根
//65535 port(端口号)
//伪随机数
public class Demo11 {
public static void main(String[] args) {
System.out.println(Math.abs(13));
System.out.println(Math.abs(-13));
System.out.println(Math.ceil(13.2));
System.out.println(Math.ceil(-13.2));
System.out.println(Math.floor(-13.2));
System.out.println(Math.floor(13.2));
System.out.println(Math.pow(2, 16));
System.out.println(Math.random());
System.out.println(Math.round(3.5));
System.out.println(Math.sqrt(8));
}
}
//System类概述
//System 类包含一些有用的类字段和方法。它不能被实例化。
//成员方法
//public static void gc()
// 调运gc方法之前 你的保证你所要回收的对象处于null引用
// 垃圾回收机制
// finalize()垃圾回收器
//public static void exit(int status)
//public static long currentTimeMillis() 当前时间的毫秒值
// 1566033662870
//public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)
//第一个参数:从哪个数组复制
//第二个参数:从原数组的第几个索引处开始复制
//第三个参数:目标数组
//第四个参数:从目标数组的第几个索引开始存储
//第五个参数:复制粘贴多少个元素
public class Demo12 {
public static void main(String[] args) {
long c = System.currentTimeMillis();
System.out.println(c);
int[] arr = {1,2,3,4,6,7,8,9};
int[] arr1 = new int[10];
System.arraycopy(arr, 2, arr1, 0, 6);
System.out.println(Arrays.toString(arr1));
}
}
//2019年8月17号 17点45分..秒
//Date类概述
//类 Date 表示特定的瞬间，精确到毫秒。
//构造方法
//public Date()
//public Date(long date)
//成员方法
//public long getTime() 将Date对象转换为对应的毫秒值
//public void setTime(long time)
//SimpleDateFormat构造方法
//public SimpleDateFormat()
//public SimpleDateFormat(String pattern)
//成员方法
//public final String format(Date date) 将Date对象转换为字符串
//public Date parse(String source) 将字符串转为Date对象
public class Demo13 {
public static void main(String[] args) throws ParseException {
Date date = new Date();
System.out.println(date);
Date d = new Date(1566033662870l);
System.out.println(d);
System.out.println(date.getTime());
date.setTime(1566033662870l);
System.out.println(date);
SimpleDateFormat sdf = new SimpleDateFormat("HH点mm分ss秒 yyyy年MM月dd号 ");
System.out.println(sdf);
String time = sdf.format(date);
System.out.println(time);
SimpleDateFormat sdf1 = new SimpleDateFormat("HH点mm分ss秒 yyyy年MM月dd号");
Date da = sdf1.parse(time);
System.out.println(da);
}
}
标签：第三阶段,String,int,System,API,println,public,out 来源： https://blog.csdn.net/weixin_45480925/article/details/99710087