本帖最后由 小石姐姐 于 2018-4-20 11:07 编辑
学习笔记
object
objectd tostring方法
string tostring():返回该对象的字符串表示
boolean equals(object obj )
getclass():返回一个字节码对象
Integer.toHexString():返回指定参数的十六进制字符串形式
hashCode():返回该对象的哈希码值(内部地址)
获取自字节码的3种方式
1.通过object类的getclass()方法获取 ------ 对象.getClass()方法
Teacher teacher =new Teacher();有对象使用这一方式
Class clazz=teacher.getClass();
2.通过类名调用属性class来获取 ------ 类名.class属性
Class clazz2= Teacher.class;
3. 通过class类的静态方法forName()来获取 ------- class.forName("类的全名")
Class class1=Class.forName("com.itheima07.Teacher");推荐使用这一方式
object的equals方法
前提:需要重写否则比较的是地址值
boolean equals(object obj )
使用==来比较俩个对象是否相等,则比较地址值是否相等
system
system:包含一些有用的类字段和方法,它不能被实例化
static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
复制数组
src:源数组
srcPos:指定从哪个索引位置开始复制
dest:目标数组
destPos:指定目标数组接收元素的索引位置
length:目标数组接收元素的个数
例子:int[]src={1,2,3,4,5};
int []dest=new int[5];
//System.arraycopy(src, srcpos, dest, destpos, length);
System.arraycopy(src, 0, dest, 0, 5);
for(int i=0;i<dest.length;i++){
System.out.print(dest);
}
---------------------------------------------------------------
static long currentTimeMillis()
返回当前系统时间
1000毫秒=1秒
0:0:1 =1000毫秒
0:1:0=1000*60
1:1:0=1000*60*60+1000*60
static void exit(int status) 非 0 的状态码表示异常终止。 0表示正常终止
终止虚拟机的运行
Data
Date: 表示特定的时间,精确到毫秒它可以通过方法来设定自己所表示的时间,可以表示任意的时间
构造方法:
Date():创建的是一个表示当前系统时间的Data对象
Date(long date):根据"指定时间" 创建Data对象
例子:Date data=new Date(1000*60);
ystem.out.println(data.toLocaleString());
常用方法: 毫秒值----Date
设置 setTime
返回值是void,参数long
void setTime(long time) 设置Date对象的时间
Date-----毫秒值
获取getTime
返回值是long,无参数
long getTime()获取Date对象中保存的时间毫秒值
simpleDateFormat类(格式化): 专门用于格式化和解析时间
格式化: Date对象-->指定格式的字符串,如2017-05-01 12:34:12
String format(Date date):格式化Date对象返回字符串
解析: 字符串->Date对象
Date parse(String source):将字符串解析为Date对象
构造方法:
simpleDateFormat();使用默认的模式进行对象构建
格式: simpleDateFormat simpleDateFormat(String pattern):使用指定的模式进行对象的构建
例子:package com.itheima07;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
* 按要求实现以下需求
将当前日期格式化为”xxxx年xx月xx日”并打印
已知日期字符串”2000-10-01”
将该日期字符串格式化为日期对象,获取该日期对象的毫秒值并打印
*/
public class test07 {
public static void main(String[] args) throws ParseException {
Date data=new Date();
SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy年MM月dd日");
String string=simpleDateFormat.format(data);
System.out.println(string);
System.out.println("---------");
String date2="2010-10-24";
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
Date date =sdf.parse(date2);
System.out.println(data);
long mils=date.getTime();
System.out.println(mils);
}
}
练习求出你来这个世界上多少天的案例
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class test08 {
public static void main(String[] args) throws ParseException {
//出生日期
String birthday="1996-06-11";
//今天日期
String now ="2018-04-09";
SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd");
//将字符串转换为日期
Date date=simpleDateFormat.parse(birthday);
Date date2 =simpleDateFormat.parse(now);
//将日期转换为long的毫秒值
long birthdaymils=date.getTime();
long nowmils=date2.getTime();
System.out.println((nowmils-birthdaymils)/1000/60/60/24);
}
}
Calendar:日历 提供了一些操作年月日时的方法
创建对象
静态方法: static Calendar getInstance()
示例: Calendar c = Calendar.getInstance();
获取 int get(int field) 获取指定的日期字段
修改 void add(int field,int amount):增加或减少指定的日期字段值(调整时间)
calendar.add(calendar.DAY_OF_MONTH,-1);
添加 void set(int field,int value):设置指定的日期字段值(设置时间)
calendar.set(calendar.YEAR, 2000);
Calender 抽象类。日历，提供操作日期字段的方法
static
Calendar getInstance() //获取对象，默认当前时间
int YEAR 年
int MONTH 年中月（0-11）
int DAY_OF_MONTH 月中天
int HOUR 小时(12小时制)
int HOUR_OF_DAY 小时(24小时制)
int MINITE 分钟
int SECOND 秒
int DAY_OF_WEEK 周中天（1-7，周日-周六）
int DAY_OF_WEEK_IN_MONTH 月中周
int DAY_OF_YEAR 年中天
包装类: character Integer(关键词)
就是封装了基本数据类型的类,为我们提供了更多复杂的方法和一些变量
Integer
构造方法
Integer(int value) : int转Integer
Integer(String value) : String转Integer
成员方法
int intValue() : Integer转int
String toString() : Integer转String
static int parseInt(String value) : String转Integer
整数基本类型和包装类转换
int转Integer
利用Integer的构造方法: Integer Integer(int value)
如: Integer i = new Integer(10);
Integer转int
利用Integer的成员方法: int intValue()
如: int a = i.intValue();
字符串和整数转换
String转int/Integer
方式1: Integer Integer(String s)
如: Integer i = new Integer("10");
方式2: static int parseInt(String s)
如: int a = Integer.parseInt("10");
方式3: static Integer valueOf(String s)
如: int b = Integer.valueOf("10");
int/Integer转String
方式1: "" + int值
如: String a = "" + 10;
方式2: String toString()
如: String a = i.toString();
方式3: static String toString(int i)
如: String a = Integer.toString(10);
正则表达式:就是一套规则可以用于匹配字符串
格式: String类
boolean matches(String regex) : 当前字符串是否匹配指定的正则表达式
Pattern 类:
创建正则表达式模板, 内有正则表达式规则
常用规则: 具体查看API文档的Pattern类
字符:
x : 一个字符x a b c "abc" "aab"
\\ : 表示 \ 反斜杠.
为什么有2个? 第一个 \ 是转义的作用
[abc] : a或b或c, 即中括号字母中的其中一个 [abc]{2} "aa"
[^abc] : 除a, b, c之外的任何字符.
^ 表示否定
[a-zA-Z] : 小写英文a到z, 以及大写英文A到Z.
- 表示范围
预定义字符
. : 任何字符(对于行结束符, 可能匹配, 也可能不匹配)
\d : 数字0-9. 相当于 [0-9]
d是digital的缩写
\D : 非数字. 相当于 [^0-9]
\s : 空白字符. 相当于 [ \t\n\x0b\f\r] , 包括空格(第一个空就是空格)
s是space的缩写
\S : 非空白字符. 相当于 [^\s]
\w : 单词字符. 相当于 [a-zA-Z_0-9]
w是word的缩写
\W : 非单词字符. 相当于 [^\w]
Greedy数量词
X? : X这个字符出现一次或零次
X* : X这个字符出现零次或多次, 包括一次
X+ : X这个字符出现一次或多次
X{n} : X这个字符恰好出现n次
X{n, } : X这个字符至少出现n次
X{n, m} : X这个字符至少出现n次, 但不超过m次
切割字符串:
String类
String[] split(String regex) : 按照正则表达式切分当前字符串为多个部分, 返回每个部分组成的字符串数组, 其中不包含分隔符
集合
Arraylist string tostring():返回该对象的字符串表示 数组用length 集合用size
集合的体系结构:
由于不同的数据结构(数据的组织,存储方式),所以java为我们提供不同的集合
将不同的集合实现类的共性向上抽取取出父类,从而形成一种体系
collection是接口不能实例化
Collection中的常用功能
如何创建Collection对象?
本身是接口, 实际使用的是子类对象. 使用多态, Collection c = new ArrayList<>();
常用方法
增
boolean add(E e) : 向集合中添加元素, 添加成功返回true, 添加失败返回false. 永远能够添加
成功
删
boolean remove(Object o) : 删除元素中的指定元素, 删除成功返回true, 删除失败返回false
void clear() : 清空集合中的元素
判断
boolean contains(Object o) : 判断集合中是否包含指定元素, 包含返回true, 否则false
boolean isEmpty() : 判断集合是否为空集合, 即没有元素. 没有元素返回true, 否则false
获取个数
int size() : 获取集合中元素的个数
转换
Object[] toArray() : 将集合转换为Object[]
T [] toArray(T[]a):传入T类型数组,将集合中元素存储到数组中
获取迭代器
格式:Iterator<Integer> lIterator=list.iterator() ;
Iterator 接口:
迭代器
作用:
提供遍历集合的安全方式
获取迭代器:
使用集合对象调用 Interator<E> iterator() 方法
成员方法
boolean hasNext() : 是否有下一个元素
E next() : 返回下一个元素
void remove() : 从迭代器指向的 collection 中移除迭代器返回的最后一个元素
并发修改异常解决方案:
并发修改异常:
ConcurrentModificationException
并发:
并行发生, 即同时发生
修改:
指的是会改变集合长度的操作
增加元素
删除元素
清空元素
list的 set(int index, Object o) 方法可以修改集合中某个索引处的元素值, 但并不会改变集
合的长度, 所以不会发生并发修改异常
发生原因:
迭代器依赖于集合, 相当于集合的一个副本, 当迭代器在操作时, 如果发现迭代器的副本和集合不一
样, 则抛出并发修改异常
如何避免:
// 添加元素
collection.add("Hello");
collection.add("world");
collection.add("java");
// 方式1: 转换为Object[]
Object[] arr = collection.toArray();
for (int i = 0; i < arr.length; i++) {
System.out.println(arr);
}
System.out.println("-------------");
// 方式2: 使用迭代器
// 先通过集合对象获取迭代器对象
Iterator iterator = collection.iterator();
// 循环迭代
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
}
方式1: 不使用迭代器
方式2: 在使用迭代器遍历时, 使用迭代器的方法修改
添加元素:
List接口中的 ListIterator listIterator() 获取用于List的迭代器, 然后调用
ListIterator的add()方法
删除元素: remove()
List接口
列表, 是Collection的子接口
特点:
元素存取有序, 元素可以重复, 有索引
泛型:
Generic type, 广泛的通用的类型, 具体什么类型由开发者定义
为什么出现泛型?
由于集合可以存储任意类型的对象, 所以可以按照Object类型存入, 如果我们向集合中存储不同类型
的对象后再遍历出来元素, 都是Object类型, 若要使用该类型的方法, 必须进行类型转换, 有可能发生
类型转换错误
例如:
集合中存储了Student对象和String对象, 迭代出元素后并不知道具体是什么, 强转或调用方法
时可能出错
好处:
避免类型转换问题
减少警告
简化代码书写
作用:
用于明确数据类型
将运行时才发生的类型转换问题, 提前到了编译时期
如何使用:
出现 <某个字母> 的地方, 就可以使用具体的数据类型替代这个字母
增强for: foreach 遍历数组和集合
for (int i = 0; i<arr.length;i++) {
int a = arr;
}
for (元素类型 变量名: 数组或集合对象) {
// 每次循环都会遍历出一个元素, 保存到变量名中
}
int[] arr = {1,2,3};
for (int i : arr) {
system.out.println(i);
}
List:
格式:list list=new ArrayList();
List 接口
继承自 Collection 接口. 在 java.util 包下
特点
元素有序(存入和取出的顺序一样)
有整数的索引
元素可以重复
特有功能 (都是按索引进行操作的)
void add(int index, E element) : 添加元素
E remove(int index) : 删除元素
E set(int index, E element) : 修改元素
E get(int index) : 获取元素
list的常用子类:
Arraylist
底层是数组结构,查询快,增删慢
Linkedlist
格式:
Linkedlist list=new Linkedlist();
底层是链表,查询慢,增删快
如何使用不同的集合?
如果查询多,增删少,就用Arraylist
如果查询少,增删多,就用Linkedlist
如果你不知道用什么,就使用Arraylist
LinkedList的特有功能
LinkedList底层使用的是链表结构,因此增删快,查询相对ArrayList较慢
void addFirst(E e) :向链表的头部添加元素
void addLast(E e):向链表的尾部添加元素
E getFirst():获取链头的元素,不删除元素
E getLast():获取链尾的元素,不删除元素
E removeFirst():返回链头的元素并删除链头的元素
E removeLast():返回链尾的元素并删除链尾的元素
set接口
格式: set<string> set =new hashset<string>();
遍历集合对象
1. 转数组
string[]arr=list.toArray();
2.迭代器依赖于集合
Iterator iterator=list.iterator();
while(iterator.hasNext()){
System.out.print(iterator.next()+",");
}
3.增强for
for (int i : arr) {
system.out.println(i);
set集合特点
1无序(存储和读取的顺序有可能不一样)
2.不允许重复(要求元素唯一)
3.没有索引
collections: 面试题：Collection和Collections有什么区别？
Collection是集合体系的最顶层，包含了集合体系的共性
Collections是一个工具类，方法都是用于操作Collection
static void swap(List list, int i, int j) :将指定列表中的两个索引进行位置互换
static void sort(List<T> list) :按照列表中元素的自然顺序进行排序
Collections.sort(list);
static void shuffle(List list):傻否，随机打乱集合中元素的顺序
static void reverse(List list) :反转集合中的元素
static void fill(List list, Object obj) :使用指定的对象填充指定列表的所有元素
static void copy(List dest, List src) :是把源列表中的数据覆盖到目标列表
static int binarySearch(List list, Object key) 使用二分查找法查找指定元素在指定列表的索引位置
MAP:
格式: Map<String , String> map=new HashMap<>();
将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。
键可以重复值不可以重复
Map的常用功能：
* 映射功能：
* V put(K key, V value)
就是key映射到value,如果key存在,就覆盖value,如果不存在将原来的value返回
* 获取功能：
* V get(Object key) 根据指定的key返回对应的value
* int size() 返回对应关系的个数
* 判断功能：
* boolean containsKey(Object key) :判断指定key是否存在
boolean containsValue(Object value) 判断指定的value是否存在
boolean isEmpty() 判断是否有对应关系
* 删除功能：
* void clear() 清空所有的对应关系
* V remove(Object key) 根据指定的key删除对应关系，并返回key所对应的值，如果没有删除成功则返回null
*
* 遍历功能：
* Set<Map.Entry<K,V>> set=map. entrySet() ;
获取方式:
for(entry<k,y> entry:set){
String key=entry.getKey();//直接获取
String vaule=entry.getValue();
*
* }
* Set<K> keySet() :set<string > key=map.keySet();
获取方式: String value=map.get(key);//赋值获取值
* Collection<V> values() :Collection<String> values = map.values();
对象实现排序的2种方式
1 元素具有排序功能，元素实现Comparable接口，重写compareTo(T o)方法
2 使用比较器，让集合自身具备比较功能
定义一个类作为比较器实现Comparator接口，重写compare(T o1,T o2)方法，把此比较器对象传递给TreeSet
重写方法返回值作用，当前元素与传入元素比，从小到大
返回<0：当前元素比传入元素小，当前对象小于指定对象
返回=0：当前元素与传入元素相等，当前对象等于指定对象，不存
返回>0：当前元素比传入元素大，当前对象大于指定对象
异常的体系结构: A: 编译时期异常:是Exception的子类，非RuntimeExcpetion的子类，在编译时期必须处理
B:RuntimeException和他的所有子类异常,都属于运行时期异常。NullPointerException,ArrayIndexOutOfBoundsException等都属于运行时期异常.
运行时期异常的特点:
方法中抛出运行时期异常,方法定义中无需throws声明,调用者也无需处理此异常
运行时期异常一旦发生,需要程序人员修改源代码.
throwable(最顶层)
nullPointerException
ArrayIndexOutofboundException
2.1Throwable常用方法
String getMessage() 返回此 throwable 的详细消息字符串
String toString() 返回此 throwable 的简短描述
void printStackTrace() 打印异常的堆栈的跟踪信息
如果出现异常我们没有处理,jvm会帮我们进行处理,他会把异常的类型,原因还有位置显示在命令行
并且终止了程序异常后面的代码不在执行
异常处理方式: throws 关键字
捕获
try...catch语句
try：该代码块中编写可能产生异常的代码。
catch：用来进行某种异常的捕获，实现对捕获到的异常进行处理。
e.printStackTrace();该方法知识将异常信息以system.err错误输出流打印到控制台,并不会终止程序
finally:组合try...catch使用
try{
有可能发生异常的代码
//放在这里
}catch(异常类型 异常对象名){
对异常进行处理的代码
}finally{
//一定会被执行的语句
例子:public class ExceptionDemo4 {
public static void main(String[] args) {
try {
System.out.println(2 / 0);
} catch (ArithmeticException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
system.out.println("hello")
}
多异常处理: try {
// 可能发生异常的代码
} catch (异常类型1 异常对象名1) {
// 处理异常1的代码
} catch (异常类型2 异常对象名2) {
// 处理异常2的代码
}
// 格式
try {
// 可能抛出异常的代码
} catch (异常类型1 | 异常类型2 异常变量名) {
// 异常处理代码
if (异常变量名 instanceof 异常类型1) {
// 处理异常类型1
} else if (异常变量名 instanceof 异常类型2) {
// 处理异常类型2
}
}
// 一般这样处理是因为2种异常的处理方式相同, 才合并写; 否则可以使用catch语句方式分别处理
finally概述和引用场景
finally关键字
作用:
与try...catch配合, 无论异常是否被捕获, 最终都会执行finally代码块中的代码
}
异常的分类
异常的分类
编译时异常: 编译时就发生的异常
Exception 及其子类(除RuntimeException体系)
处理方式: 编译时期必须处理(try...catch或throws)
运行时异常: 编译时正确, 但运行时发生的异常
RuntimeException 类及其子类
处理方式: 编译时期可以自由选择处理或不处理
自定义异常
自定义异常
自定义编译时异常类:
定义一个类, 继承 Exception 或其子类(非RuntimeException), 重写构造方法
自定义运行时异常类:
定义一个类, 继承 RuntimeException 或其子类, 重写构造方法
使用自定义异常的方式:
使用编译时异常:
在方法声明上, 使用 throws 抛出 Exception 或其子类的类型(除RuntimeException体系)
使用运行时异常:
在方法内部的代码中, 使用 throw (注意没有s)抛出 RuntimeException 或其子类的对象
throws和throw的区别:
throws : 用于抛出编译时异常, 在方法声明上使用
throw : 用于主动抛出运行时异常, 在方法中使用
递归: 必须定义一个方法 然后方法自己调用自己
|
|
收藏
淘帖
踩
