1.Object类
Object类是Java语言中的所有类的超类，即所有类的根。它中描述的所有方法，所有类都可以使用。
equals( ) : 指示其他某个对象与此对象“是否相等” (比较的是两个对象的“内存地址”是否相同，一般要重写该方法)
toString( ): 返回该对象的字符串表示 (是该对象的唯一标识: 类名+@+该对象的哈希码值的16进制字符串表示 / 类名+@+内存地址值)，一般会重写 toString( ) 方法
hasCode( ): 返回该对象的哈希码值。1
public class Rectangle { //长方形类 private int length; private int width; public int getLength() { return length; } public void setLength(int length) { this.length = length; } public int getWidth() { return width; } public void setWidth(int width) { this.width = width; } //重写toString()方法 @Override public String toString() { return "Rectangle{" + "length=" + length + ", width=" + width + '}'; } @Override //重写equals()方法: 改掉之前其是判断对象的内存地址是否一致的判断内容 public boolean equals(Object obj) { Rectangle r = (Rectangle) obj; //如果两个长方形的长和宽相等，则其是相等的、相同的 if (this.length == r.getLength() && this.width == r.getWidth()) { //重写了equals()方法让其判断长宽，而不是判断两个对象的内存地址是否相等 return true; } else { return false; } } }
- clone( ) ：
创建并返回原对象的一个副本。按照原对象，创建一个新对象（复制对象的内容），但对象的地址/对象的哈希值 不同，是两个不同的对象。Person.java1
public class Person implements Cloneable{ //实现Cloneable接口 int id ; String name; int [] arr; public Person(int id,String name,int [] arr) { this.id = id; this.name = name; this.arr = arr; } /* 重写clone()方法 */ @Override public Person clone() throws CloneNotSupportedException { return (Person) super.clone(); } /* 重写toString()方法 */ @Override public String toString() { return "Person{" + "id=" + id + ", name='" + name + '\'' + ", arr=" + Arrays.toString(arr) + '}'; } }Test.java
public class Test { public static void main(String[] args) throws CloneNotSupportedException { int arr [] = new int[]{1,2,3}; Person p1 = new Person(1,"张三",arr); System.out.println(p1); //Person{id=1, name='张三', arr=[1, 2, 3]} Person p2 = p1.clone(); System.out.println(p2); //Person{id=1, name='张三', arr=[1, 2, 3]} //克隆了原对象的内容，但两个对象的地址/哈希值是不同的，是不同的两个对象 } }
2.String类
String类是不可变的字符串,一旦String类被创建,该对象中的字符序列将不可改变 。
String的两种初始化方式:
①字符串赋值方式:
如: String str1 = “helloWorld”;
这种方式创建字符串时，JVM首先会检查字符串常量池中是否有该“字符串对象”，如果字符串常量池中存在该对象，那就不会在字符串常量池中再创建了，直接返回该字符串对象在字符串常量池中的“内存地址”。 如果字符串常量池中不存在该对象，那就先在字符串常量池值中创建该“字符串对象”，后返回
常量池中的内存地址。②构造函数初始化方式:
如: String str2 = new String(“hello world”);
用这种方式创建字符串的时候，JVM首先会检查“字符串常量池”中 是否存在该对象(helloworld)。
如果存在 则不会在字符串常量池中创建了。后会到堆内存中创建一份字符串的对象（String对象 ）,
把字符串常量池中的 “helloWord”字符串内容拷贝到内存中的字符串对象中，最后返回堆内存中字符串对象(String)的“内存地址”。
如果不存在，会先在字符串常量池中创建"HelloWorld"字符串，后到堆内存中创建一份字符串String对象，把字符串常量池中的“helloWorld”拷贝到堆内存中的字符串对象中。最后返回堆内存中字符串对象的“内存地址”。/* 如果字符串常量池中有该字符串，则返回其在字符串常量池中的内存地址。 如果字符串常量池中没有该字符串，先在常量池中创建，后返回其在字符串常量池中的“内存地址”。 */ String str1 = "hello world"; /* * 如果字符串常量池有“hello World”字符串存在，则不会在字符串常量池中创建。后在堆内存中创建一个字符串对象，把常量池中的该对象拷贝到堆内存的 * 字符串对象中。最后返回堆内存中的字符串对象的“内存地址”给: str2(对象的引用，存储的是该对象的内存地址) * 如果字符串常量池中的“hello World”字符串不存在，则先在字符串常量池中创建。后在堆内存中创建一个字符串对象，把常量池中的该对象拷贝到堆内存的 * 字符串对象中。最后返回堆内存中的字符串对象的“内存地址”给: str2 */ String str2 = new String("hello World");public class Demo1 { public static void main(String[] args) { //用构造方法创建一个String字符串对象 String str1 = new String("abcd");//先检查字符串常量池中有没有...，后在堆内存中创建字符串对象...,最后返回该对象的内存地址 System.out.println("str1=" + str1); //通过byte数组来创建字符串对象 byte[] buf = {97, 98, 00, 100, 101, 102}; String str2 = new String(buf); System.out.println("str2=" + str2); //从字节数组的下标1开始,长度为3来创建字符串对象 String str3 = new String(buf, 1, 3); System.out.println("str3="+str3); //用字符数组来创建字符串 char[] c = {'我', '是', '一', '个', '学', '生'}; //字符数组 String str4 = new String(c); System.out.println("str4="+str4); String str5 = new String(c, 1, 3); //从字符数组的下标1开始，长度为3来创建字符串对象 } }public class Demo2 { public static void main(String[] args) { String str = "safANFiohkla12312sfbajksbhjkRFS"; computerNumber(str); } private static void computerNumber(String str) { int bigCount = 0; //大写字母的个数 int smallCount = 0; //小写字母的个数 int numberCount = 0; //数字的个数 for (int i = 0; i < str.length(); i++) { //获取指定位置上的字符 char ch = str.charAt(i); //获得字符 if (ch >= 'A' && ch <= 'Z') { //该字符在这个范围内，则其是大写字母 bigCount++; } else if (ch >= 'a' && ch <= 'z') { //小写字母的范围 smallCount++; }else if (ch >= '0' && ch <= '9') //0-9数字的范围 numberCount++; } System.out.println("小写字母的个数为: " + bigCount); System.out.println("大写字母的个数为: " + smallCount); System.out.println("数字个数为: " + numberCount); } }/* 将字符串中第一个字母转换为大小，其他转换为小写，并打印改变后的字符串 */ public class Demo2 { public static void main(String[] args) { //创建一个字符串对象 String str = "abcadASDAF"; System.out.println(covert(str)); } //将第第一字母转换为大写，其他字母转换为小写 private static String covert(String str) { //获取第一个字母 String start = str.substring(0, 1); //左开右闭 //获取除第一个字母之外的其他字母 String end = str.substring(1); //从下标1开始往后的字母 //将第一个字母转换为大写 String big = start.toUpperCase(); String small = end.toLowerCase(); //把这两部分字符串连接在一起，得到一个完整的字符串 return big + small; } }
3.StringBuffer类
String类是不可变的字符串,一旦 String类被创建,该对象中的 字符序列将不可改变
不同于String，StringBuffer(字符串缓冲类)的“内容和长度”是可变的。StringBuffer类似于一个
字符容器，在其中不断添加和删除字符时,并不会产生新的StringBuffer对象。(ps: 字符串加入到StringBuffer后，将转换为一堆字符存储在其中。
public class Demo { public static void main(String[] args) { //使用StringBuffer的无参构造方法创建一个字符缓冲类 StringBuffer sb = new StringBuffer(); System.out.println(sb);//输出空白，因为该字符串缓冲类中还没有数据 //往字符串缓冲类中添加字符串 sb.append("abcdabcfaabc"); System.out.println(sb); //在指定的索引位置下插入数据 sb.insert(2, "小明"); //索引2下的插入一个字符串，如有冲突会将其中的字符往后挤。 System.out.println(sb); //删除指定范围内的数据 sb.delete(3, 6); //左开右闭 System.out.println(sb); //根据指定的索引删除指定的一个字符 sb.deleteCharAt(5); System.out.println(sb); //将指定范围的索引替换为想要替代的“字符串” ---字符串添加到字符串缓冲区中就变成字符，操作的也是其中的字符 sb.replace(1, 5, "陈小明"); System.out.println(sb); //翻转字符串的中内容 sb.reverse(); System.out.println("翻转: "+sb); //将指定索引下的字符替换成你想要换的字符 sb.setCharAt(3, '红'); System.out.println(sb); //截取子串 String subString = sb.substring(2,5);//左闭右开 System.out.println("子串的内容为: " + subString); //查找指定的“字符串”在StringBuffer中第一次出现的索引值 int index = sb.indexOf("abc", 0); //从索引0处开始往后找 System.out.println("索引值为: "+index); //如没找到时，返回-1 //追加数据 sb.append("JavaJava"); System.out.println(sb); //查看字符数组的长度 System.out.println("字符数组长度为: "+sb.capacity()); //查看StringBuffer的长度 System.out.println("StringBuffer中字符个数为(长度为): " + sb.length()); //根据指定的索引找指定位置的字符 System.out.println("指定索引位置的字符为: " + sb.charAt(5)); System.out.println(sb); } }
4.Math类
Math 类是包含执行基本数学运算的方法的“数学工具类”,如初等指数、对数、平方和三角函数等。
Math类的两个常量: PI(常量π) 和 E(常量e)
Math类特点:
其所有方法为静态方法，并且一般不会创建对象。public class MathTest { //Math类的相关内容 public static void main(String[] args) { //ceil()方法，结果为比参数值大的最小整数的double值 double d1 = Math.ceil(3.3); //4.0 double d2 = Math.ceil(-3.3); //-3.0 double d3 = Math.ceil(5.1); //6.0 System.out.println(d1 + " " + d2 + " " + d3); //floor方法, 结果为比参数值小的最大整数的double值 double d4 = Math.floor(3.3); //3.0 double d5 = Math.floor(-3.3);//-4.0 double d6 = Math.floor(5.1); //5.0 System.out.println(d4 + " " + d5 + " " + d6); //round方法,返回参数四舍五入的结果 double d7 = Math.round(5.5); //6 double d8 = Math.round(5.4);//5 System.out.println(d7 + " " + d8); //max方法,返回两个参数中值较大的值 double d9 = Math.max(3.3,5.5); //5,5 double d10 = Math.max(-3.3,-5.5);//-3.3 System.out.println(d9 + " " + d10); //min方法同理 //random方法，产生一个大于等于0.o小于1.0的double小数 System.out.println("--------------------"); double d11 = Math.random(); //产生一个大于等于0.0 小于1.0的double值 System.out.println(d11); } }
5.Random类
在JDK的包下有一个Random类，它可以在 指定的取值范围内（自定义范围）产生随机数。
Random类有两个构造方法如果使用相同的种子，那么产生的随机数序列是一样的，这就意味着如果想要生成相同的随机数序列，那么种子相同即可。
（如果两个Random对象的种子是一样的，那么两者生成的随机数也会是一样的）Random( ) : 生成一个为随机数生成器。
Random( long seed ) : 使用“特定的种子”来创建为伪随机数生成器(如果两个Random对象的种子是一样的，那么其生成是随机数也会是一样的)public class RandomTest { //Random类的相关内容 public static void main(String[] args) { /* 如果使用相同的种子，那么生成的随机数序列是一样的。那就意味着， 如果想要生成相同的随机数序列，只需要使用相同的种子即可。 */ //创建一个没有种子的Random对象 Random random1 = new Random(); for (int i = 0; i < 5; i++) { //产生5个0-100之间的随机数 (左闭右开) int num = random1.nextInt(100);//左闭右开 System.out.print(num+","); } System.out.println(); /* 因为两个Random对象没有用同一个种子，所以产生的5个随机数不一样会相等 */ Random random2 = new Random(); for (int i = 0; i < 5; i++) { //产生5个0-100之间的随机数 (左闭右开) int num = random2.nextInt(100);//左闭右开 System.out.print(num+","); } System.out.println(); System.out.println("----------------------"); //创建有种子的Random对象,种子为13 Random random3 = new Random(13); for (int i = 0; i < 5; i++) { //产生5个0-100之间的随机数 int num2 = random3.nextInt(100); System.out.print(num2+","); } /** * 这里和上面用的是同一个种子的Random对象,所以产生的5个随机数和上面产生的5个随机数是一样的 */ System.out.println(); Random random4 = new Random(13); for (int i = 0; i < 5; i++) { //产生5个0-100之间的随机数 int num2 = random4.nextInt(100); System.out.print(num2+","); } } }
6.包装类
在Java很多类都需要接入引用类型的对象，此时就无法将一个基本数据类型的值传如入。
为了解决这一系列的问题，JDK提供了一系列的包装类。通过包装类可以"基本数据类型"的值为引用数据类型的对象。包装类特点: 在Java中，每一种基本类型都有对应的包装类。
public class Demo1 { //包装类的相关内容 public static void main(String[] args) { int i = 10; //基本数据类型 double d = 20.0; //将"基本数据类型"转换为String类型 String str1 = String.valueOf(i); String str2 = String.valueOf(d); System.out.println(i+" "+d); //创建包装类: Integer Integer i1 = 20; //包装类型 Double d1 = 30.0; System.out.println(i1+" "+d1); //用toString()方法,返回值为String类型 //包装类中的方法被重写了,输出的值 String str3 = i1.toString(); String str4 = d1.toString(); System.out.println(str3+" "+str4); } }public class Demo2{ public static void main(String[] args) { String str1 = "50"; String str2 = "30.41"; String str3 = "true"; //用包装类的.parseInt()方法将字符串类型数据转换为int类型 int num1 = Integer.parseInt(str1); //用包装类将String类型转换为double类型 double num2 = Double.parseDouble(str2); boolean bool = Boolean.parseBoolean(str3); System.out.println(num1+" "+num2+" "+bool); } }public class Demo3 { public static void main(String[] args) { //用包装类的valueOf()方法将String类型数据转换为"包装类型" String str1 = "50"; String str2 = "30.41"; String str3 = "true"; //字符串转换为包装类型 Integer i = Integer.valueOf(str1); Double d = Double.valueOf(str2); Boolean b = Boolean.valueOf(str3); System.out.println(i+" "+d+" "+b); } }
扫一扫
399
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
