关于学习Java中常用类的总结
关于学习Java中常用类的总结
关于学习Java中常用类的总结一、序言
由于第一次写博客，而且也已经决定走Java方向，还是想先简单聊聊JAVA面向对象的编程思想，之前在学习的过程中，听到一个老师对其最后的总结为 “以类的方式组织代码，以对象的方式组织（封装）数据”随着学习的深入，也慢慢开始理解这句话。 对象：现实生活中具体的事务。 类：是对对象的抽象。 类作为编程中最基本的单位，它可以构成我们想要表达的所有事务，而最近刚好在张老师那里学到几个常用类，接下来是我的学习总结。
二、学习总结——常用类
1、object类
object作为所有类的超类，无论是四类八种的基本类型还是引用类型或者是自定义类型都需要extends Object,所以其自然有着强大的功能，它的主要方法有
需要注意的几个方法，
（1）、finalize:protected void finalize() throws Throwable:当垃圾回收器确定不存在对该对象的更过引用时，由对象的垃圾回收器调用会此方法，但是什么时候调用垃圾回收器不确定。在System类中的一个方法： public void gc()垃圾回收器最终调用的就是这个方法。
（2）、clone: Object类中的clone方法执行特定的复制操作，首先如果对象不能实现接口Cloneable，则会抛出 CloneNotSupportedException。
（3）、toString：在平时编程中，我们都有这样的发现 System.out.println(oo)的输出与Systeml.out.println(oo.toString)输出结果一样， 为什么呢？
这是因为System.out.println方法在打印引用时若引用不为空，则首先调用指向对象的toString方法获取字符串，然后打印字符串的内容，当然如果我们没有重写toString方法，就按Object类实现获取字符串，打印出来的内容就是this.getClass.getName + @ + Integer.toHexString(this.hashCode)，一般就比较难理解，所以好多大神都建议当自定义类时，最好重写toString方法,这样我们也就可以显示成员变量的值。
（4）、equals：方法的重要意义
在一般初学者眼里，觉得自己能够辨识”equals“方法和”==“就很流弊了，前者比较其实例的值，后者比较实例的地址。很对，但是如果你不深入理解源码去看的话，很容易掉入各大公司的陷阱里面。其实equals的底层实现依然是”==“，以下为源码：
惊不惊喜？意不意外？
所以，如果你业务有需要，想实现equals方法最终输出为true,那还是乖乖的在自定义时重写equals方法吧，又会问，那int、char、String等方法也没见我重写啊，输出来就是true啊，那是因为可爱的Java创始人在JDK5.0就创造了包装类。所谓包装类我把他定义为数据类型界的暖男，平时不声不响，当他的女朋友——基本数据类型或String类需要处理数据时，他就会默默的为”她“auto-boxing,unbosing(自动装箱、自动装箱)，当然此处你要把他两看作一家人（包装类有时候被我们简化，我们不能直观看到）。
2、Scanner类
（1）、类的功能： 该类的主要作用就是建立一个文本扫描器（键盘录入），存在于java.util包下。在键盘的录入过程中，Scanner sc = new Scammer(System.in),
System类中的静态字段为：
public static final InputStream in: 标准输入流
InputStream :字节流 InputStream is = System.in ; 实质:抽象类多态
public static final OutputStream out: 标准输出流
（2）、判断功能：在录入数据之前添加逻辑判断，hasNextXXX()，判断是否由下一个可以录入的XXX类型的数据。nextXXX()，通过录入来获取这个int类型的数据，如果输入数据与判断数据不一致，则会抛出java.util.InputMismatchException(输入和想得到的数据不一致)
（3）、注意事项：先录入int类型的数据再录入String类型的数据，String没有接收到，直接输出结果了，这是由于“回车”导致的，一回车。直接输出结果。
解决方案有二：其一，使用next()方法，其二，再创建一个键盘输入对象录入String类型。
3、包装类的——Why?When?where?
一个姓牛的人曾经说过，学习最大的动力就是永远有问不完的问题。（如果你没听说过这句话，那就现在盯着屏在看一遍吧
）
上了大概20年的学，我们都清楚，学知识有三问—Why?When?where?
1）why？
其实Java并不是纯面向对象的语言。比如，java中的基本数据类型就不是面向对象的，但是我们在实际运用中经常要将基本数据类型转化为对象便于操作。
2）when??
什么时候使用包装类？自然是你需要操作数据的时候，例如进制之间的相互转化、数据之间的比较（compare）、求出该类型的最大最小值...
3） where???
第一个where: 包装类都位于Java.lang包下
第二个where: 至于在那用，根据具体问题具体定夺。
3、String类
（1）、类的功能代表字符串，Java程序中所有的字符串字面值（如“abc”）都作为此类的实例实现，字符串一旦被赋值，其值不能被改变。
String s = "hello",与String s = new String("hello")两个有什么区别？分别创建了几个对象？
答：第一个创建了一个对象，第二个创建了两个对象（堆内存中有new String(),然后字符串常量池中也有这样一个字符串常量（开辟了地址空间））
（2）、String类常用的构造方法:
* String():表示一个空字符序列。
* public String(byte[] bytes,Charset ch):默认字符集(编码格式):GBK,如果是GBK格式,可以不写第二个参数
* public String(byte[] bytes,int index,int length):将部分字节数组构造成一个字符串
* public String(char[] value):将字符数组构造成一个字符串
* public String(char[] value,int index,int length):将部分的字符数组构造成一个字符串
* public String(String original):通过字符串常量构造一个字符串对象
（3）、注意事项：其一、数组中没有length()方法，它有length属性。字符串中有length(),集合中没有length(),有size()获取集合中元素的数量。
其二、字符串变量相加，先开辟空间，再相加。字符串常量相加，首先在字符串常量池中找，判断有没有这个常量值，没有需要创建，有，则直接返回。
（4）、编码与解码格式一样（默认为GBK格式，一个中文对应两个字节。utf-8编码，一个汉字对应三个字节）。
（5）、String类中的判断功能：
boolean equals(Object obj):当前该对象是否obj这个对象是否相等;
boolean equalsIgnoreCase(String str):比较字符串是否相等,忽略大小写
boolean contains(String str):判断str这个字符串是否包含在当前字符串中
boolean startsWith(String str):是否以str子字符串开头
boolean endsWith(String str):判断是否以str子字符串结尾
boolean isEmpty():判断字符串是否为空
（6）、String类中转换功能：
String类的转换功能(重点)
byte[] getBytes():将字符串转换字节数组
char[] toCharArray():将字符串转换成 字符数组 (开发中经常使用)
static String valueOf(char[] chs):将字符数组转换成字符串
static String valueOf(int i):将一个int类型的数据转换成字符串
注意:
String类中的valueOf()可以将任何数据类型转换成字符串
String toLowerCase():将字符串全部转成小写
String toUpperCase():将字符串全部转换成大写
String concat(String str):字符串拼接方法
（7）、String类的其他功能：
替换功能:
* public String replace(char oldChar,char newChar):将字符串中某一个字符用新的字符替换
* public String replace(String oldStr,String newStr):将字符串中某一个子字符串用新 的字符串去替代
* 去除字符串两端空格:
* public String trim()
两个字符串进行比较:
* public int compareTo(String anotherString) 是Comparable接口中的方法(该接口可以实现一个自然排序)
* Comparator接口可以比较器排序
（8）、插播递归：
自己调用自己的方法，称为方法递归，递归的三个条件：A需要定义方法，B要有出口条件，C满足一定的规律
4、StringBuffer类
（1）、StringBuffer:线程安全的可变字符序列。
（2）、StringBuffer的构造方法:
* public StringBuffer ()构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符
* public StringBuffer(int capacity)构造一个不带字符，但具有指定初始容量的字符串缓冲区
* public StringBuffer(String str)
* 构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。该字符串的初始容量为 16 加上字符串参数的长度。
（3）、获取长度和容量的方法：
* public int length():获取字符串长度数
* public int capacity():获取当前字符串缓冲区的容量
（4）、StringBuffer中的和添加有关的方法：
* public StringBuffer append(int/String/char/boolean/double/float....):当前这个方法追加,给缓冲中追加数据,返回字符串缓冲区本身(经常使用的)
* public StringBuffer insert(int offset,String str):在某一个位置处去插入str这个字符串,返回字符串缓冲区本身
（5）、StringBuffer的删除有关方法:
* public StringBuffer deleteCharAt(int index):删除指定位置处的字符,返回的是字符串缓冲区本身!
* public StringBuffer delete(int start,int end):删除从指定位置开始到指定位置结束的字符,返回的是字符串缓冲区本身!
（6）、StringBuffer的反转功能:
* public StringBuffer reverse():将此字符串中的字符序列直接反转
（7）、StringBuffer的替换功能:
* public StringBuffer replace(int start, int end,String str)
从指定位置开始到指定位置结束的字符用str子字符串去替代
（8）、StringBuffer的截取功能:
* public String substring(int start):从指定位置默认截取到末尾,返回值是一个新的字符串
* public String substring(int start,int end):从指定位置开始截取到指定位置结束,包前不包后,返回一个新的字符串
（9）、StringBuffer和String 的区别?
* StringBuffer会构造一个字符串缓冲区,从内存角度考虑,一般情况使用StringBuffer比较多(在单线程程序中使用StringBulider替代
* StringBuilder:线程不安全,单线程单纯为了提供执行效率!)
* String:普通的一个字符串,从内存角度考虑,耗费空间!
（10）、StringBuffer和数组的区别？
都属于容器类型的变量，数组只能存储一种类型的数据，并且长度是固定的，StringBuffer可以存储任意类型的元素。
（11）、静态代码块 ,构造代码块,构造方法的优先级问题:
静态代码块>构造代码块>构造方法...
例子：
class B{
/* private static ArrayList<String> array ;
public B(){
array = new ArrayList<String>() ;
}*/
//成员变量的位置
public static B t1 = new B() ;
public static B t2 = new B() ;
{
System.out.println("构造代码块");
}
static{
System.out.println("静态代码块!");
}
}
public class Demo {
public static void main(String[] args) {
B b = new B() ;//构 构 静 构
//静态代码块 ,构造代码块,构造方法的优先级问题:
//静态代码块>构造代码块>构造方法...
}
}
5、Integer类
（1）、自动拆箱、自动装箱： 上面说到自动拆、装箱，这是在JDK5.0之后添加进来的（java的jkd5.0以后:还有一些新特性:可变参数,增强for循环,静态导入,枚举... ）。引用前辈的话说，自动拆箱装箱其实就是编译器帮我们改进代码。
例如：int C = new Integer(15000); 相当于 new Integer(15000).intValue //自动拆箱
Integer B = 15000; 相当于 new Integer(15000).intValue //自动装箱
特别需要注意的是： 在【-128，127】之间的int数，JVM依然当作基本数据类型进行处理，目的是为了加快代码的执行效率。
（2）、基本数据类型对应的引用类型。
* 基本类型 引用类型
* int Integer
* char Character
* byte Byte
* boolean Boolean
* double Double
* float Float
* long Long
* short Short
* 将基本类型--->引用类型的作用:就是为了和String类型作为转换
6、character
（1）、 Character 类：在对象中包装一个基本类型 char 的值。Character 类型的对象包含类型为 char 的单个字段
构造方法:
* public Character(char value)构造一个新分配的 Character 对象，用以表示指定的 char 值。
（2）、* Character类的判断功能:
* public static boolean isLowerCase(char ch)确定指定字符是否为小写字母。
* public static boolenn isUpperCase(char ch)确定指定字符是否为大写字母
* public static boolean isDigit(char ch)确定指定字符是否为数字。
*
* Character常用的转换功能:
* public static char toUpperCase(char ch):将指定字符转换成大写
* public static char toLowerCase(char ch):将指定字符转换成小写
（3）、 例题：
第一题 * 需求:键盘录入一个字符串,统计该字符串中大写字母字符,小写字母字符,数字字符有多少个(不考虑其他字符,使用Character提供的判断功能去完成)
public class CharacterDemo2 {
public static void main(String[] args) {
//public static boolean isLowerCase(char ch)确定指定字符是否为小写字母
System.out.println("isLowerCase:"+Character.isLowerCase('a'));
System.out.println("isLowerCase:"+Character.isLowerCase('A'));
System.out.println("isLowerCase:"+Character.isLowerCase('0'));
System.out.println("---------------------------------------");
//public static boolenn isUpperCase(char ch)确定指定字符是否为大写字母
System.out.println("isUpperCase:"+Character.isUpperCase('a'));
System.out.println("isUpperCase:"+Character.isUpperCase('A'));
System.out.println("isUpperCase:"+Character.isUpperCase('0'));
System.out.println("---------------------------------------");
//public static boolean isDigit(char ch)确定指定字符是否为数字。
System.out.println("isDigit:"+Character.isDigit('a'));
System.out.println("isDigit:"+Character.isDigit('A'));
System.out.println("isDigit:"+Character.isDigit('0'));
}
}
第二题： 需求:键盘录入一个字符串,统计该字符串中大写字母字符,小写字母字符,数字字符有多少个(不考虑其他字符,使用Character提供的判断功能去完成)
* 分析:
* 1)定义三个统计变量
* bigCount
* smallCount
* numberCount
* 2)创建键盘录入对象,录入并接收一个字符串
* 3)将字符串转换成字符数组
* 4)遍历字符数组,获取到每一个字符
* 5)使用Character类中的判断功能判断是否是大写,小写,数字字符
* 6)输出
*
public class CharacterTest {
public static void main(String[] args) {
//定义三个统计变量
int bigCount = 0 ;
int smallCount = 0 ;
int numberCount = 0;
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//录入并接收数据
System.out.println("请您输入一个字符串:");
String line = sc.nextLine();
//将字符串转换成字符数组
char[] chs = line.toCharArray() ;
for(int x = 0 ; x < chs.length ; x ++){
//获取每一个字符
char ch = chs[x] ;
//判断
if(Character.isUpperCase(ch)){
bigCount ++ ;
}else if(Character.isLowerCase(ch)){
smallCount ++ ;
}else if(Character.isDigit(ch)){
numberCount ++ ;
}
}
//输出
System.out.println("大写字母字符共有:"+bigCount+"个");
System.out.println("小写字母字符共有:"+smallCount+"个");
System.out.println("数字字符共有:"+numberCount+"个");
}
}
7、冒泡排序
（1）、冒泡排序的思想： 两两比较,大的往后放,第一次比完,最大值出现在最大索引处,依次进行这样的比较....
（2）、终极版冒泡排序代码：（在张老师的基础上，我又加了一个判断条件，避免数组已经排好序之后在重复排序）：
public static void Start(double[] arr) {
for(int i=0;i<arr.length-1;i++) {
boolean alread = true;//假定有序
System.out.println("第"+ i+1 + "轮");
for(int j=0;j<arr.length-1-i;j++) {
if(arr[j]>arr[j+1]) {
double temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
alread = false;//交换值了，说明之前是无序的
}
System.out.println(Arrays.toString(arr));//本轮排序后的数组
}
if(alread == true) {
break;
}
}
}
public static void main(String[] args) {
double[] d = {10,50,400.2,600,900};
Start(d);
System.out.println(Arrays.toString(d));
}
投递牛客等公司10个岗位 >
