走进Java 3
常用类
Object 类
public int hashCode(); 获取对象的hash值 支持散列表 , 支持键值对key value
hashCode(); 哈希算法 理解为地址值,每个对象的hash码值不同
String toString(); 返回对象的字符串表示形式,结果应该是一个更容易看懂的读懂的信息表达式,
建议所有子类都覆盖这个方法,几乎java所有类都会重写toString方法
直接输出对象名称和使用对象名.toString()是等价的
== 和 equals() 方法的区别?
前者比较 两个基本类型,比较的是数据值是否相等 连接两个引用类型,比较的是地址值是否相等
后者Objects的equals方法,默认比较的是两个引用类型地址值是否相等,建议子类重写equals(),
重写之后比较的是两个对象的成员信息是否相同,重写equals方法,必须重写hashCode方法
重写equals比较的是每个对象的成员信息是否一样,如果一样还要比较它的hashCode,如果都一样
系统才会认定两个人一样
Object的克隆方法:
public object clone() throws CloneNotsupportedException 创建对象并返回它的副本
它的方法中本身就有克隆不支持异常
要进行创建对象的副本,前提是这个类必须要实现clone 接口,否则无法克隆
jdk提供接口,什么都没有,方法也没有,这个接口称为"标记接口" implement Cloneable
java.util.Scanner. 文本扫描器
构造方法:
Scanner 对象名 = new Scanner(System.in) 创建键盘录入
成员方法:
next XXX(); 获取功能
int nextInt(); 录入int类型 int number = sc.nextInt()
String nextLine(); 录入String 类型 String line = sc.nextLine()
判断功能:
boolean hasNextInt(); 判断录入的下一个数据是否为int类型,是返回true ,否则false
Boolean hasnextLine(); 判断录入的下一行数据为一行内容
键盘录入的时候:
先录入的int ,在录入String --- nextLine,这里会出现被漏掉("回车符号")
解决方案:
1>在录入第一个int之后,重新创建一个新的键盘录入对象Scanner,然后再使用nextLine()
2>在录入String --- String next()
String 类
final修饰这个类,不能被继承
字符串不变,它的值在创建后不能被更改(字符串是个常量,存储在常量池中)
推荐创建方式: String s = "xxx" ; 开发中推荐的方式
构造方法:
public string(); 空字符串 类似等于String s = " " ;
public string (string original); 构造一个字符串对象,里面指定一个字符串常量值
public string (byte[] bytes , int offect , int length); 将一部分字节数组构造成字符串
public string( char [] value); 将字符数组构造成string
byte[] bytes = {97,98,99,100,101} ; String s3 = new String(bytes) ;
public string( char[] value , int offect , int length) ; 将一部分字符串数组构造成字符串
面试题:
数组中有没有length ,字符串中有么有length , 集合中有没有length?
答: 数组中没有length 属性 字符串有length 集合没有length,获取集合元素数是size()
面试题:
string s = new string ("hello"); 和 string s = "hello" 有什么区别?分别创建了几个对象?
答: 前者在堆内存中开辟空间,然后字符串值常量指向常量池,两个对象
后者为推荐方式 , 直接常量赋值,然后再常量池中找,有就返回地址,没有就开辟空间
推荐方式:常量赋值,字符串是常量,一旦赋值,其值不能被更改
获取功能:
s.charAt(x): 获取指定位置处的字符
s2.concat(s3): 将s2和s3两个字符串拼接起来
s5.substring(5): 从指定位置截取到末尾
s5.substring(3,5); 从指定位置截取到指定位置,包前不包后
s.split("-") 按照指定分割符号拆分
转换功能:
s.toCharArray(); 将字符串转换成字符数组
Arrays.toString(s); 将任意类型数组转换成String
s.toUpperCase(); 将字符串转换成大写
s.toLowerCase(); 将字符串转换成小写
String.valueOf(x); 将任意数据类型转换成String (万能方法)
判断功能:
s.contains(x); 判断大串是否包含小串
s.endWith(x); 判断是否以指定结尾
s.startsWith(x); 判断是否以指定的开头
s.equals(s1); 判断两个字符串内容是否相同
s.replace(x,y); 用y替换x
+拼接符号和concat比较哪个高效?
显然 "+"比较高效一点, conant 拼接时左边不能为空,不然会导致空指针异常NullPointerException
StringBuffer
字符串缓冲区
线程安全类,支持可变字符序列 线程依赖进程,线程执行的最小单元
线程安全 同步 执行效率低
线程不安全 不同步 执行效率高
构造方法:
StringBuffer(); 空参构造,初始容量16个字符
StringBuffer(10); 指定容量字符串缓冲区
s.length(); 获取字符串缓冲区长度
s.capacity(); 获取容量大小
获取功能:
s.append(任意类型); 将指定类型追加字符串缓冲区序列
s.charAt(x); 获取缓冲区指定位置字符
s.delete(2,5); 删除从指定位置到指定位置结束 包前不包后
s.deleteChar(3); 删除指定位置处的字符,返回本身
s.replace(2,5,"gao"); 指定位置处y用指定字符替换 可以是任意类型
s.insert(2,""gao"); 指定位置处插入指定字符 可以是任意类型
截取功能:
s.substring(5): 从指定位置截取到末尾
s.substring(3,5); 从指定位置截取到指定位置,包前不包后
特有功能:
反转
s.reverse(); 将字符串缓冲区的字符序列反转
String和StringBuffer的区别?
前者常量,一旦被赋值,其值不可更改,不可变的字符序列,作为形参,它的改变不影响实参的改变,
和基本类型作为形参一样,String是特殊的引用类型
后者支持可变的字符串序列,线程安全类,同步效率低,作为形参,它的改变影响实际参数
StringBuilder是和StringBuffer具备相互兼容的API,线程不安全类,不同步,效率高
单线程程序,只考虑效率,使用StringBuilder去替代StringBuffer
多线程环境,考虑安全,使用StringBuffer
Integer
int ---- Integer-------静态常量
Integer.MIN_VALUE 最小值
Integer.MAX_VALUE最大值
Integer.toBinaryString(x); 将十进制转成二进制
Integer.toOctalString(x); 将十进制转成八进制
Integer.toHexString(x); 将十进制转成十六进制
构造方法:
Integer.(x); 将int类型数据包装为Integer类型
Integer(x); 将字符串类型包装成Integer类型 字符串类型必须为数字字符串 如"10" 不然数字格式化异常
JDK5以后新特性:
1>自动拆装箱子
2>静态导入,导入到方法级别,前提方法必须为静态
3>增强for循环
4>可变参数
**类型转换
int----String int-----Integer-----toString
String-----int String -----Integer ------intValue 或者直接万能方法 parseXXX方法
任意基本类型对应的类型都存在 Integer.parseInt()
Character
包装一个字符char类型 ---->character
成员方法:
Character.isDigit(x); 判断是否为数字字符
Character.isUpperCase(x); 判断是否为大写字符
Character.isLowerCase(x); 判断是否为小写字符
Date
格式化或者解析:使用DateFormat类,他是一个抽象类,不能实例化,用的抽象类的子类SimpleDateFormat
String日期文本---->Date 解析
Date日期格式-----> String 格式化
SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
y代表年份; M代表月; d代表日 H代表小时; m代分钟; s代表秒
构造方法:
Date(); 系统时间的日期格式
成员方法:
date.getTime(); 获取date对象的系统时间毫秒值
Random 伪随机数生成器
构造方法:
Random r = new Random();
成员方法:
r.nextInt(20); 随机数的取值范围是0-20
Calendar
日历类,是一个抽象类,不能实例化
创建日历: Calender c = new getInstance()
成员方法:
c.get(Calender.YEAR / Calender.MONTH / Calender.DAY ); 获取年/月/日 月份只到11,需在输出时+1
Calender 提供静态字段: 成员变量---->静态变量
Calender.YEAR / Calender.MONTH / Calender.DAY
BigDecimal
作用针对小数进行精确计算
构造方法:
BigDecimal bg = new BigDecimal("小数字符串"/"整数"/"浮动类型")
成员方法:
bg.add(2); 加
bg.subtract(2); 减
bg.mutiply(2); 乘
bg.divide(2); 除
集合
集合和数组的区别?
长度区别,存储类型的区别,存储元素的区别
collection
接口 跟接口 通过具体的子接口List/Set的子实现类实现
创建集合需要带上泛型
c.add(x); 添加元素
c.remove(x); 删除元素
c.claer(); 清空元素
c.isEmpty(); 判断集合是否为空
c.contains(x) 判断集合是否包含指定元素
迭代器:
获取迭代器 Iterator<String> it = c.iterator()
it.hasNext() 判断是否有下一个元素
it.Next() 获取元素
标准代码:
while(it.hasNext() ){
String s = it.Next();
system.out.println(s);
}
JDK5 提供加强for循环
目的就是为了替代迭代器(集合,存储引用类型),简化代码书写程度
for(泛型类型 名字: 集合名称){
使用变量名遍历元素
}
增强for循环的特点:前提条件,集合或者数组对象不能为空,否则会空指针异常报错
List 集合
允许集合元素重复,而且有序集合
创建集合: List<String> s = new ArrayList<>();
List特有功能:
s.add(2,"gao"); 在指定位置前面插入新的元素
s.get(2); 获取指定位置处的元素
s.set(2,"gao"); 在指定位置处替换指定元素
List集合特有专有遍历------>列表迭代器
ListIterator<String> lit = list.listIterator();
hasNext + next 正向遍历
hasPrevious + previous 反向遍历 (必须有正向遍历)
Vector 集合
线程安全的类(底层结构是数组,查询快,增删慢)
特有功能:
v.addElement(x); 将指定元素追加到集合中
v.elementAt(x); 通过索引值获取指定元素 类似List集合的 l.get(x);
int size(); 获取集合元素数
特有遍历方式:
for(int x = 0 , x<size()) , x++){
String s = v.element(x);
system.out.println(s)
}
特有遍历方式2: 枚举组件接口
Enumeration<String> en = v.elements();
while(en.hasMoreElements()){
String s = en.nextElement();
System.out.println(s);
LinkedList
线程不安全,不同步,执行效率高
底层数据结构是链表,查询慢,增删快
创建链表: LinkedList<String> lk = new LinkedList<>() ;
特有功能:
添加元素:
lk.addFirst(x); 指定元素添加到链表开头
lk.addEnd(x); 指定元素添加到链表结尾
lk.getFirst(); 获取第一个元素
lk.getEnd(); 获取最后一个元素
lk.removeFirst(); 删除第一个元素并返回第一个元素
lk.removeLast(); 删除最后一个元素并返回
Set
元素唯一,默认情况下使用HashSet进行实例,创建对象
HashSet的底层依赖于HashMap,元素唯一,迭代顺序无法保证
它的底层依赖于HashMap的put 方法 依赖于hashCode/equals,而且存储String类型,重写了hashCode/equals,保证元素唯一
TreeSet的底层基于TreeMap<k,v>,红黑树,有自然排序和比较器排序
构造方法:
创建空树,里面元素必须要实现Comparale接口,重写compareTo()方法,完成比较
比较器比较,使用匿名对象重写comparator方法
Map和Collection 的区别
Collection 单列集合,只能存储一种引用类型数据,遍历方式和Map不同,它的应用范围大
Map 双列集合,可以存储键值对,遍历方式,获取所有的键,通过键找值
Map
键唯一,一个键可以有多个值
基本功能:
m.put(x,y); 添加键值对
m.remove(x); 删除键,返回键对应的值
m.clear(); 暴力删除,将集合清空
m.containKey(x); 判断是否包含指定的键,返回true或false
m.containValue(y); 判断是否包含指定的值,返回true或false
遍历方式:
1>获取所有键,通过键找值
Set<String> s = m.keySet();
for加强循环,通过键获取值 String value = m.get(s);
2>遍历所有映射项(一个键对应一个值)
Set<Map.Entry<String, String>> entry = map.entrySet() ;
for加强循环,获取键值对对象,键和值 String key = en.getKey(); String value = en.getValue();
如果键值对的键是自定义类型,那么需要考虑对象的唯一,要针对键有效,需要键的类型,需要重写equals和hashCode
equals比较的是内容是否一样,hashCode比较的是成员信息的哈希码值是否一样
TreeMap排序也是自然排序和比较器排序同TreeSet
103
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
