本帖最后由 小石姐姐 于 2018-4-20 10:49 编辑
【石家庄校区】JavaEE学习笔记_二阶段5-8
第五天:
>>>>>>>>>>> 常用API : <<<<<<<<<<<
>>>Class 类:
Class类 没有公共构造方法。
Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的
>>>> Object类的方法使用 <<<<<
Object 类:
是类层次结构的根类.每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法
String toString(); //返回该对象的字符串表示(对象的字符串表示形式)
return getClass().getName()+"@"+Intefer.toHexString（hasCode()）;
getClass():返回一个字节码对象;
字节码对象:当类的字节码文件加载到方法去后会产生一个字节码对象
getClass().getName():获取该类的全类名(包名,类名)
Integer.toHexString():返回指定参数的十六进制字符串形式
hashCode():返回该对象的哈希码值(也就是内部地址)
---------
toString()方法使用:
/*Object类的toString()方法
* 默认情况下:tostring()方法输出的是 全类名@该类的字节码地址
* return getClass().getName() + "@" + Integer.toHexString(hashCode());
*
* 一般使用的时候都会重写:格式如下,这个在eclipse中可以自动生成
* return "Student [name=" + name + ", age=" + age + "]";
*/
public class JiCheng {
public static void main(String[] args) {
Student s = new Student();
System.out.println(s.toString());//com.ithema.test.Student@10f3801
System.out.println(s);// 这两行输出的内容是一样的,说明toString()方法是默认的,因为所有
//的类都继承与Object类,toString()方法就是继承与Object类.
}
}
//学生类
class Student{
String name;
int age;
@Override //这个重写的toString方法是自动生成的 source--Generter toString..
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
}
---------------
>>>>> 字节码对象 <<<<
同一个类的字节码对象只有一个,地址值是相同的,无论创建了多少个对象(一个类的对象的字节码对象是一样的)
Class和class区别?
Class是一个类,表示字节码文件的类
class是一个关键字,用于定义一个类
三种方式:
1. 使用Object类的方法获取
Object 类 class getClass() 方法
2. 通过类名调用属性class来获取
类名.class 属性
扩展:实际上.class是一种特殊形式,称为< 类字面常量 >, class是关键字不能作为属性名,
且Object类中,并没有定义这个属性
3.使用Class类的forName(String s);方法获取
注意:使用第三个方法时,因为该方法用字符串来寻找类,有可能并没有该字符串对应的类,
所以会抛出ClassNotFoundException类无法找到异常.
/*
* 获取字节码对象的方式 演示
* 先了解获取方式
* 后期会学习反射
*/
public class JiCheng {
public static void main(String[] args) throws ClassNotFoundException {
//方式1 通过Object类的getClass()方法获取
Teacher t1 = new Teacher();
Teacher t2 = new Teacher();
Class clazz1 = t1.getClass();
Class clazz2 = t2.getClass();
System.out.println(clazz1);
System.out.println(clazz2); //输出的是一个包含全路径的类名
//方式1 打印结果 class com.ithema.test.Teacher
//同一个类下的对象,的字节码对象都是一样的
//方式2 通过类名调用属性class来获取
Class clazz3 = Teacher.class;
System.out.println(clazz3);
//方式2 打印结果 class com.ithema.test.Teacher
//方式3 通过Class类的静态方法forName()来获取
Class clazz4 = Class.forName("com.ithema.test.Teacher");
System.out.println(clazz4);
}
}
------------------------
重写Object类的equals()方法:
/*
*boolean epuals(Object obj)
* 快捷键:
ctrl+shift+T ----写入要查找的类---ctrl+O"ou"--找到方法--单机--出现源码
* 功能是查看类的源码
选中要封装的代码 ---shift+alt+m---生成一个方法
*
* public boolean equals(Object obj) {
return (this == obj);
}
* 上边是 Object类中equals的源码 方法中使用双等"=="比较两个对象是否相等,比较地址值是否相等
因此String类才会重写String方法,不重写的就不不能比较字符串内容是否相等了,
在下边这个类中我们想比较两个两个对象是否相等,就需要重写Object类的equals()方法,
得到我们想要的功能,可以自己重写,也可以利用eclipse提供的功能重写equals()方法
eclipes提供的方法比较健壮. 右击--soure--hashCode()&equals(),生成后
删除hashCode方法就行了;
*
*/
public class JiCheng {
public static void main(String[] args) throws ClassNotFoundException {
}
}
//人类
class Person{
String name;
int age;
public Person(String name,int age){
this.name= name;
this.age = age;
}
@Override
public int hashCode() { //将hashCode()方法删除就行了,暂时用不到
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj) //判断两个对象的地址是否相同
return true; //地址相同说明是同一个对象,放回ture
if (obj == null) //判断传进来的对象是不是空值
return false; //是的话返回false
if (getClass() != obj.getClass()) //比较两个对象的的字节码对象是否相同,相同的话
//话说明两个对象属于同一个类,这样可以提高代码的健壮性,
//因为该equals(Object obj)的参数是Object类,因此可以
//传进任何对象,如果不判断的话,在下边进行了(多态)对象由大到小转换
//后,进行属性判断时就会报错,(调不出对应的属性)
return false;
Person other = (Person) obj; //判断两个对象属于同一个类后,就可以进行有大到小的转换了(多态,因为
//传进来的对象是父类指向子类的形式,所以要将其进行转换,转换后就可以进行
//对象内属性的比较了,如果不转换的话,传进来的对象只能访问子父类都有的属性)
if (age != other.age) //利用!=判断intl类型的年龄是否相等
return false;
if (name == null) { //判断调用equals()方法的对象的name变量地址是否为空
if (other.name != null) //判断传进来的对象的name变量地址是否为空
return false;
} else if (!name.equals(other.name)) //利用String类的equals()方法判断name变量内的字符串是否相等
return false;
return true;
}
}
------------------------------------------------------------------------
system类部分方法的使用:
/*
* System:包含一些有用的类字段和方法,它不能被实例化(构造方法被私有),是一个工具类
返回系统当前时间 毫秒值:
static long currentTimeMillis()
从1970-1-1 00:00:00 开始计算(0时区)
-----------------------------------
*1970-1-1 00:00:00 ,是英国的时间
*中国对应的时间是 1970-1-1 08:00:00 (东8区)
-----------------------------------
终止虚拟机的运行:
* static void exit(int status)
* 复制数组:
* static void arraycopy(Object src,int srcPos,Object dest,int destPos,int lenggth)
* 数据源和目的地
*
* src:数据源
* srcPos:指定从哪个索引位置开始复制
* dest:目标数组
* destPos:指定目标数组接受元素的索引位置
* length:目标数组接受元素的个数
* arraycopy()方法使用注意事项:
length的长度+src起始位置!>src.length-1;
length的长度+dest起始位置!>dest.length-1;
*/
public class SystemDemo {
public static void main(String[] args) {
int[] src = {2,3,4,7,8,9,0};
int[] dest = new int[5];
System.arraycopy(src, 0, dest, 0, 3);
//虽然复制方法好用,但一定注意接受长度length不能大于源数组从开始索引
//至最后索引的长度,防止发生越界问题
for(int i=0;i<dest.length;i++){
System.out.println(dest);
}
}
}
-----------------------------------------------
util包中的
Date类:
import java.util.Date;
/*
* util包下的Date 类:
* 表示特定的时间,精确到秒,它可以通过方法来设定自己所表示的时间,可以表示任意的时间
* 有三个子类: sql包下的Date类:是一个跟数据库有关的类
* Time
* Timestamp
*System.currentTimeMills():返回的是当前系统时间,1970-1-1至今的毫秒数
*
* util.Date类的构造方法:
* Date():创建的是一个表示当前系统时间的Date
* Date(long date):根据"指定时间"创建Date对象
* 毫秒: 1000*60*60*24 为一天
*
* /Date 的常用用法:
* 毫秒值--->Date
* 设置
* 返回值是void,参数long 都是毫秒值
* void setTime(long time)
* Date(long date)
* Date--->毫秒值
* 获取
* 返回long,无参数
* long getTime()
*/
public class SystemDemo {
public static void main(String[] args) {
//Date 构造方法1
Date d = new Date(); //创建一个表示当前系统时间的对象
System.out.println(d);
//打印结果:Mon Mar 19 08:29:30 CST 2018
System.out.println(d.toLocaleString());
//打印结果2018-3-19 8:31:17,d.toLocaleString()可以返回
//看着比较方便的这种格式,但是已经过时,不建议使用
//Date(long date) 构造方法2
Date d2 = new Date(0);
System.out.println(d2.toLocaleString());
//打印结果为 1970-1-1 8:00:00 ,输入的是0秒,但打印的结果
//却不是1970-1-1 00:00:00,是因为它打印的是东八区的时间
//setTime(long date)
d2.setTime(1246754567877L);
System.out.println(d2);
//打印 Sun Jul 05 08:42:47 CST 2009
}
}
----------------
DateFormat类: 时间日期格式化类
不可以创建对象,但可以用多态的特性,用父类的索引名指向子类对象,
也就是指向 SimpleDateFromat类的对象
直接子类为 : SimpleDateFromat类:
toLocaleString()可以打印处 1970-1-1 00:00:0 这种格式
但是这个方法已经过时,这时就需要用到一个新的方法,使用DateFormat类,
进行时间日期的格式化
-----
DateFormt类的使用方法:
由于该是抽象类不能创建对象:
1.直接用类名调用它的静态方法
2.创建它的子类SimpleDateFormat类的对象,来使用
DateFromat方法
-----
SimpleDateFormat 类:
是一个以与语言环境有关的方式来格式化和
解析日期的具体类。它允许进行格式化（日期 -> 文本）、
解析（文本 -> 日期）和规范化。
注意: 日期的 格式化 和 解析 用的是两个类的方法(父类DateFormat , 子类 SimpleDateFormat)
格式化:
Date--->String
Date类打印格式2029-8-26-->我们想要的格式2029年8月26日
用DateFormat 抽象类的 String format(Date date) 方法
解析:
String--->Date
当我们需要将"2029-8-26"加一天时,因为它是一个字符串
不能进行加减,所以时间格式的字符串转换为Date对象,转换为毫秒值
再进行加减.
用SimpleDateFormat 类的 Date parse(String source) 方法
这就是SimpleDateformat类最重要的两个任务.
构造方法:
SimpleDateFormat() :默认的模式进行对象的构建
SimpleDateFormat(String pattern) :使用指定的模式进行对象的构建
注意:
格式化用的什么格式 , 解析式时就要用什么样的格式
例 :格式化格式为"yyyy年MM月dd日"
解析的时候也要使用"yyyy年MM月dd日"这种模式,
否则会报错..而且要用同一个对象(也就是谁格式化的,还要用谁解析)
SimpleDateFormat类 案例讲解:
package com.test.jy05;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class SystemDemo {
public static void main(String[] args) throws ParseException {
//method(); //封装成方法
//method2(); //封装成方法
//method3();
//计算出生时间
//出生日期
String birthday = "1998-06-05";
//今天
String now = "2018-03-19";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
//将字符转换成日期对象
Date d1 = sdf.parse(birthday);
Date d2 = sdf.parse(now);
//将日期对象转换为long类型
long l1 = d1.getTime();
long l2 = d2.getTime();
//计算天数
long day = (l2-l1)/(1000*60*60*24);
System.out.println(day);
}
private static void method3() throws ParseException {
//使用指定模式进行对象的构建
//1999年9月1日 10:10:10
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss:S:z");
Date date = new Date();
//格式化
String s = sdf.format(date);
System.out.println(s);
//打印结果 2018年03月19日 11:33:26:437:CST
//解析
Date d = sdf.parse("2018年03月19日 11:33:26:437:CST");
System.out.println(d.toLocaleString());
//打印结果 :2018-3-19 11:33:26
}
private static void method2() throws ParseException {
//使用指定的模式进行对象的构建
//看API文档查看SimpleDateFormat类的日期格式表示 ( 区分大小写 )
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
//格式化
Date date = new Date();
//将日期对象转换为设定好格式的字符串
String s = sdf.format(date);
System.out.println(s);
//打印结果 : 2018年03月19日 跟设定的格式"yyyy年MM月dd日"一样;
//解析
Date d = sdf.parse("2018年03月19日");
System.out.println(d.toLocaleString());
//打印结果 2018-3-19 0:00:00
}
private static void method() throws ParseException {
//使用默认的模式进行对象的构建
SimpleDateFormat sdf = new SimpleDateFormat();
//创建日期对象
Date date = new Date();
//格式化 把日期对象转换成字符串
String s = sdf.format(date);
System.out.println(s);
//打印结果 18-3-19 上午10:56 ,不知道18是2018还是3018
//所以可以定义格式SimpleDateFormat对象创建时的格式
//解析 把字符串转换成日期对象
Date d = sdf.parse("18-3-19 上午10:56");
//此处需要抛出一个异常throws ParseException
System.out.println(d);
//打印结果 Mon Mar 19 10:56:00 CST 2018
}
}
--------------------------------
Calendar类的使用:
static Calendar getInstance()
使用默认时区和语言环境获得一个日历。
例:
Calendar c = Calendar.getInstance();
package com.test.jy05;
import java.util.Calendar;
/*
* calender 类 : 日历的意思
* 提供了一些操作年月日是的方法
*
* 获取 int get(int file);
* int get(给定日历字段的值);
* Calendar类里的常量字段对应的值,查API文档
*
* 修改void set(int field, int value)
* void set(日历字段值, 修改后的值) 设置的数值超过该字段的
上限后它会往前进位(跟数字的加减规则一样),去修
改高位的值(影响高位值)
*
* 添加void add(int field, int amount)
* void add(日历字段值, 要增加/减少的值) 加减的数值超过该字段的
上限后它会往前进位或减位(跟数字的加减规则一样),去修
改高位的值(影响高位值)
void clear()将日历的所有字段都设置成默认值,也就是1970-1-1
void clear(int File) 将给定的字段设置成默认值
例: Calendar c = Calendar.getInstance;
c.clear(Calendar.MONTH);
*/
public class CalendarDemo {
public static void main(String[] args) {
//public static Calendar getInstance()
Calendar c = Calendar.getInstance();
//------修改方法的使用--------
// void set(int field, int value)
// void set(日历字段值, 修改后的值)
c.set(c.DAY_OF_MONTH, 1);
//-----添加方法的使用-----
//void add(int field, int amount)
//void add(日历字段值, 要增加/减少的值)
c.add(c.MONTH, 1);//当前月加一
System.out.println(c.get(c.MONTH)+1);
//打印结果 为 4 (当前月为3月)
c.add(c.MONTH, -1);//当前月减一
System.out.println(c.get(c.MONTH)+1);
//打印结果为 3 (上边是4月减一)
//---------获取方法的使用--------
//int get(int file); //返回给定日历字段的值
int year = c.get(c.WEEK_OF_YEAR);
//在这想获取 年 使用YEAR的常量字段值就行了,YEAR的常量值为1,
//c.YEAR 获取的是当前字段对应日历的值 ,YERA对应的值为"1"
//因此c.get(1)就可以 ,获取相应日历字段的值"1"表示年,返回当前年份"2018"
System.out.println(year);
//打印结果 2018
//但是这些数字比较难记因此使用c.YEAR 就行了,
int year1 = c.get(c.YEAR);//写入对应的日历字段就行了
System.out.println(year1);//打印结果 2018
// 获取月这个地方需要+1,因为MONTH获取的是0-11月
int month = c.get(c.MONTH)+1;
int day = c.get(c.DAY_OF_MONTH); // 获取 月中的天
System.out.println(year1+"年"+month+"月"+day+"日");
}
}
------------------------------------------------------
基本数据类型封装类的使用:
package Day01;
/*
* 需求:判断一个数是否符合int类型的范围
* 由于基本数据类型只能做一些简单的操作和运算,所以Java为我们封装了基本数据类型,为
* 每种基本数据类型提供了包装类,就是封装了基本数据类型的类,为我们提供了更多复杂的方法
* 和一些变量
*
* byte Byte
* short Short
* char Character
* int Integer
* long Long
* float Float
* double Double
* boolean Boolean
*
* Integer:
* String--->int
* 方式1: int intValue()
* 方式2: static int parseInt(String s)
例: int a = Integer.parseInt("10");
方式3: static int vauleOf(String s)
例:Integer a = Integer.vauleOf("10");
* int---->String
* 方式1: +"" 数字加一个空字符串
* 方式2: String toString()
方式3: static String toString(int i)
*
* 构造方法:
* Integer(int value)
* Integer(String s)
*
*
*JDK1.5特性
*
* 注意:
* 以后在定义javaBean时里边的基本数据类型都定义成包装类型
*
* 自动装箱:
* Integer i = 10; //在语法上看把一个基本数据类型复制给Integer对象,是错误的;
* 但是它有自动装箱
* 相当于:Integer i = new Integer(10);
* 自动拆箱:
* Integer i = 10;
* int a = i;//直接把Integer对象,赋给基本数据类型,在语法上看也是错误的,涉及到了自动拆箱
*
* Integer i2 = 12;
* Integer i3 = new Integer("10");
* int a = i2+i3;
* 相当于: int a = i2.inValue() + i3.inValue();
*
import javax.swing.JFrame;
public class dd {
public static void main(String[] args) {
//字符串转数字
//Integer(String s)
Integer i = new Integer("10");
System.out.println(i); //打印结果为 数字 10
//int intValue()
int a = i.intValue();
//调用方法将对象 i 转为数字
System.out.println(a+10);
//打印结果为 20
//static int pareseInt(String s)
int b = Integer.parseInt("20");
System.out.println(b+10);
//打印结果 数字 30
//Integer(int value)
Integer i2 = new Integer(40);
String s = i2.toString();
System.out.println(s);
//静态toString方法
//static String toString(int i)
String s2 = Integer.toString(50);
System.out.println(s2);
//打印结果为 50
}
}
--------------------------------------------------
正则表达式: 概述及使用
java 中的空白字符 [\t\n\x0B\f\r]
\t 横向制表符
\x0B 垂直制表符,垂直tab
package com.ithama.day07;
/*
* 正则表达式:就是一套规则,可以匹配字符串
*String类的 matches 方法:
* boolean matches(String regex):判断当前字符串是否匹配指定的正则表达式,
* 如果匹配则返回true,否则返回false
*/
public class Teacher {
public static void main(String[] args) {
String qq = "12345";
boolean flag = qq.matches("[1-9][0-9]{4,14}");
//[1-9]判断首位非零,[0-9]判断第二位为0到9之间的数,[0-9]{4,14}加起来
//表示后边的首位数之后的位数个数在4-14之间,且都是0到9之间的数字
System.out.println("qq号判断"+flag);
//打印结果: true
//判断字符串"qaq"中间的字符 是否是元音 aeiou AEIOU
String str = "qqaqq";
//第三种方法 使用正则表达式
boolean flag1 = str.matches("\\w{2}[aeiouAEIOU]\\w{2}");
// \w 表示单词字符：[a-zA-Z_0-9],但由于\为转义字符
//所以使用\w时 要用双斜杠 \\w
System.out.println("元音字符判断"+flag1);
}
//判断中间字符是否有元音字符
public static boolean check(String s){
//转为小写
s = s.toLowerCase();
//第一种方法
char ch = s.charAt(1);//qaq 中间字符索引为 1
/*if(ch == 'a'||ch == 'e'||ch=='i'||ch=='o'||ch=='u'){
return true;
}*/
//第二种方法
String str = "aeiou";
return str.contains(ch+""); //字符加空字符串变为字符串
//当且仅当此字符串包含指定的 char 值序列时，返回 true。
// return false;
}
}
--------------------
pattern类的使用:
典型的调用顺序是 :
Pattern p = Pattern.compile("a*b");
Matcher m = p.matcher("aaaaab");
boolean b = m.matches();
只使用一次时可以这样用:
boolean b = Pattern.matches("a*b", "aaaaab");
--------------------
String 类中使用到正则表达式的一个应用:
String input = "1 fish 3 fish red fish blue fish";
Scanner s = new Scanner(input).useDelimiter("\\s*fish\\s*");
System.out.println(s.nextInt());
System.out.printl (s.nextInt());
System.out.println(s.next());
System.out.println(s.next());
s.close();
System.out.println("\f------>>");
---------------------------------------------
>>>>>>>>>> 点的拆分
String s1 = "-1.9.89";
String[] s = s1.split("\\.");
for(int i=0;i<s.length;i++){
System.out.println(s);
}
---------------------------------------------
第六天
Collection类的使用: ArrayList<E>集合的顶层类
package com.ithema.jyday06;
import java.util.ArrayList;
import java.util.Collection;
/*
* ArrayList
* 集合的体系结构:
* 由于不同的数据结构(数据的组织,存储方式),所以Java为我们提供了不同的集合
* 但是不同的集合他们的功能是相似的,不断的向上抽取出来,将共性抽取出来,
* 这就是集合体系结构形成的原因.
*
* 体系结构:
* 怎么学习?从最顶层学习,因为最顶层包含了所有的共性
* 怎么使用?使用最底层,因为最底层就是具体的实现
*
* Collection 顶层
* |
* List
* |
* ArrayList 底层
*
*
* boolean add(E e)
确保此 collection 包含指定的元素（可选操作）。
void clear()
移除此 collection 中的所有元素（可选操作）。
boolean contains(Object o)
如果此 collection 是否包含指定的元素，则返回 true。
boolean isEmpty()
如果此 collection 不包含元素，则返回 true。
boolean remove(Object o) 如果删除返回true 未删除 返回false
从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。
Object[] toArray() 将集合转换为一个Object类型的数组
返回包含此 collection 中所有元素的数组。
*
*/
public class JYDay06_1 {
public static void main(String[] args) {
//addarr();
//创建集合对象
//Collection c = new Collection();
//collection是接口,不能实例化
Collection c = new ArrayList();
//利用 多态, 父类引用指向子类对象,来使用Collection的方法
//boolean add(E e) 添加元素
System.out.println(c.add("hello"));
System.out.println(c.add("word"));
//永远可以添加成功,因为ArrayList它允许重复
//可以查看ArrayList 源码中的 add方法
//void clear() 清空集合
c.clear();
//boolean contains(Object o) :判断集合是否包含指定的元素
System.out.println(c.contains("java"));
//打印结果 false
//boolean isEmpty() :判断集合是否为空
System.out.println(c.isEmpty());
//打印结果 : true
//boolean remove(Object o) :删除元素
System.out.println(c.remove("hello"));
//打印结果为: true ;因为刚才已经清空集合
//int size() :返回集合中元素的个数
System.out.println(c.size());
c.add("hello");
c.add("java");
//Object[] toArray() ;将集合转换为一个Object类型数组
Object[] objs = c.toArray();
//因为集合可以存放任意类型的对象,所以不知道集合内放的是什么类型的对象,
//所以用Object类型(任意类型)接受
for(int i=0;i<objs.length;i++){
System.out.print(objs+" ");
}
System.out.println(objs);
}
private static void addarr() {
//创建集合对象
ArrayList al = new ArrayList();
//添加元素
al.add("Hello");
al.add("World");
al.add("Java");
//遍历
for(int i=0;i<al.size();i++){
System.out.println(al.get(i));
}
}
}
---------------------------------------------
>>>>>>>>> 泛型 <<<<<<<<<<
package com.jichuday10;
/*
* 使用集合存储自定义对象并遍历
* 由于集合可以存储任意类型的对象,当我们存储了不同类型的对象,就有可能在转换的时候出现类型转换异常.
* 所以Java为了解决这个问题,给我们提供了一种机制,叫做泛型
*
* 泛型:
* 是一种广泛的类型,把明确数据类型的工作提前到了编译时期,借鉴了数组的特点
*
* 泛型的好处:
* 避免类型转换的问题
* 可以减少黄色警告先的出现
* 可以简化我们的代码书写
*
* 什么时候可以使用泛型:
* 查阅API文档 ,当类名后跟有<E>时就说明可以使用泛型
*
*
*
*/
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class FanXingTest1 {
public static void main(String[] args) {
//创建集合对象
Collection<Student> c = new ArrayList<Student>();
//Collection<E> 泛型
//创建元素对象
Student s1 = new Student("郭靖","18");
Student s2 = new Student("黄蓉","18");
//添加元素对象
c.add(s1);
c.add(s2);
//遍历集合对象
Iterator<Student> it = c.iterator(); //Iterator<E> 泛型
while(it.hasNext()){
Student str = it.next();
System.out.println(str);
}
//在不加泛型的情况下将Student类对象从集合中取出来,然后强转存入String对象中,
//就会抛出,如下异常: 类型转换异常 ClassCastException
//Exception in thread "main" java.lang.ClassCastException:
//com.jichuday10.Student cannot be cast to java.lang.String
//at com.jichuday10.FanXingTest1.main(FanXingTest1.java:24)
}
}
------------------------------------------------------------
>>>>>>>>>>>> 增强for循环 foreach <<<<<<<<<<<<<<<
/*
* foreach : 增强型for循环,一般用于遍历集合或数组
* 格式:
* for( 元素的类型 变量 : 集合或者数组的对象){
* 可以直接使用变量
* }
*
* 注意: 在增强for循环中不能修改集合,否则会出现并发异常.
* 因为增强for循环是靠迭代器实现的.
* ------------------------------------
* 接口 Iterable<T>中的方法:
* public Interface Iterable<T>
* 接口 Iterable<T>中有这样一句话:
* 实现这个接口允许对象成为"foreach"语句的目标
*
* 注释: 1. foreach 增强for循环的底层为迭代器
* 2. 是因为实现了Iterable的类就拥有了
* Iterator<T> iterator() 这个
* 方法,就可以用迭代器去遍历该类
*
*/
public class ForeachTest {
public static void main(String[] args) {
//创建集合对象
Collection<String> c = new ArrayList<String>();
//添加元素
c.add("hello");
c.add("word");
c.add("java");
//怎强for循环遍历集合
//第一种 Collection没有加泛型时.
/*
* Collection c = new ArrayList();
* 因为Collection没有加泛型,所以他是任意类型
* 那他接受的 元素就是任意类型,所以for循环处的
* 数据类型变量用Object obj
*/
/*1*/for(Object obj : c){
System.out.println(obj);
}
//第二种 Collection加泛型时
/*
* 因为定义了String,所以元素的类型变量
* 使用的是String 类型
*/
/*2*/for(String s : c){
//将集合中的字符串对象转换为大写
System.out.println(s.toUpperCase());
}
//第三种 在集合遍历的过程中.对集合元素进行增加/删除
/*
* 运行时抛出 : 并发修改遗产
* Exception in thread "main" java.lang.Error
* : Unresolved compilation problem:
String cannot be resolved to a variable
at com.jichuday10.ForeachTest.main(ForeachTest.java:60)
原因:forech的底层为迭代器
*/
/*3*/for (String string : c) {
c.add("andriod");
System.out.println(string);
}
}
}
-------------------------------------------------------------
>>>>>>>>> 迭代器遍历修改集合 <<<<<<<<<<<
package com.jobday06;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
/*
* 集合的遍历方式:
* 1.toArray(),把集合转换成数组,然后遍历数组即可
* 2.iterator(),可以返回一个迭代器对象,我们可以通过迭代器对象来迭代集合
* iterator,是Collection的一个方法
*
*
* Iterator:可以用于遍历集合 //它是个接口
* E next();返回下一个对象
* boolean hasNext() :判断是否有元素可以获取
*
* 注意:Exception in thread "main" java.util.NoSuchElementException
* 使用next方法获取下一个元素,如果没有元素可以获取,则出现NoSuchElementException
* 这时就需要用到 boolean hasNext() 方法了
*
* 需求: 判断集合中是否包含元素java,如果有就添加元素android
* 并发修改异常:
*
*/
public class diedaiqi {
public static void main(String[] args) {
// method();
// 创建集合对象
// Collection c = new ArrayList(); //用List替换的语句
// 添加元素
// c.add("hello");
// c.add("word");
// c.add("java");
//
//method2(c);
//------------------------------------------
//-----需求------//
//---判断集合中是否包含元素java,如果有就添加元素android----//
//第一种方法判断集合何种是否有java
// if(c.contains(java)){
// c.add("android");
// }
//第二种 不适用方法contains
//我们可以获取集合中的每一个元素,然后再进行比较
//一共两种方法 转数组法/迭代法
//我们可以通过遍历来获取集合中的每一个元素,然后进行比较
/*Iterator it = c.iterator();
while(it.hasNext()){
String s = (String)it.next();//将获取的元素转为字符串类型
if(s.equals("java")){
c.add("android");
}
}*/
//用第二种方法时 抛出异常: 并发修改异常:
//Exception in thread "main" java.util
//.ConcurrentModificationException
/*原因:
* 迭代器在进行获取元素的操作时候,并不是在集合中,而是在一个副本中
* 迭代器是依赖于集合的,相当于集合的一个副本,当迭代器在操作的时候,如果发现
* 和集合不一样,就会抛出异常
*
* 解决方案:
* 1. 不去使用迭代器
* 2.在使用迭代器进行遍历的时候使用迭代器来进行修改
* 但是迭代器Iterator中没有修改集合的方法,但是他的子类ListIterator<E>
* 有,ListIterator<E>不是Collection的子类,因此Collection不能调用
* 多态的方法去调用ListIterator<E>接口的方法,又因为ListIterator<E>
* 是接口所以它不能有实体(对象),但文档中提示可以用List.listIerator,
* 虽然collection是List的父类但它看不到子类的特殊类.
* 因此就不能使用Collection c = new ArrayList();这句代码了
* 要换成List c = new ArrayList();
* 使用ArrayList<String> c = new ArrayList<String>();也行
*
* List类中的方法:
* listIterator() 返回值为ListIterator<E> 类型
* listIterator() 方法的功能: 返回此列表元素的列表迭代器（按适当顺序）。
* 这样就可以用ListInterator下的add(E e)方法了
* ListIterator<E>.add(E e) : 将指定的元素插入列表（可选操作）。
* 这样就实现了用迭代器去修改集合元素的功能,这样就不会报错了
*
*
* 那把上边的话注释掉,用下边的新代码
*
*/
//创建List对象 ,List为Collection的子类
List c = new ArrayList();
//向集合内添加元素
c.add("hello");
c.add("word");
c.add("java");
//修改前输出
System.out.println(c);
//获取列表迭代器对象 ,也就是ListInterator对象,以便使用
//迭代器add()方法,去向迭代运行的集合遍历进程中,去操作集合.
//避免抛出 "并发修改异常"
ListIterator lit = c.listIterator();
while(lit.hasNext()){
String s = (String)lit.next(); //迭代
if(s.equals("java")){
lit.add("android");
}
}
System.out.println(c);
}
private static void method2(Collection c) {
//获取迭代器对象
Iterator it = c.iterator();
//Object next() :返回下一个元素
if(it.hasNext())
System.out.println(it.next());
if(it.hasNext())
System.out.println(it.next());
if(it.hasNext())
System.out.println(it.next());
// System.out.println(it.next());
//集合中一共有三个元素,但是使用了四次迭代器,
//这时程序就会报错,抛出一个异常
//java.util.NoSuchElementException
//这时就要用到boolean hasNext()方法了
//替换上方的代码
while(it.hasNext()){ //it.hasNext 为true则说明
//还有元素可取
System.out.println(it.next());
//通过迭代器的方法输出元素
}
}
private static void method() {
// 创建集合对象
Collection<String> c = new ArrayList<String>();
// 添加元素
c.add("hello");
c.add("word");
c.add("java");
// 获取数组
Object[] objs = c.toArray();
// 遍历数组
for (int i = 0; i < objs.length; i++) {
System.out.println(objs);
}
}
}
---------------------------------------------------
>>>>>>>>>>> 常见数据结构 (数组)<<<<<<<<<<<<<
数组: int[] arr = {1,2,3,4,5};
数组的特点: 查找快，增删慢
数组的长度一旦定义则不可改变
数组中的元素都有整数索引
数组只能存储同一类型的元素
数组既可以存储基本数据类型,也可以存储引用数据类型
如何获取元素3？
可以通过索引获取，arr[2];
想要在元素3后边添加一个新的元素8，怎么办？
首先创建一个新的数组，长度是原先数组长度+1；
便利原先得数组，并且插入到新的数组中，但碰到元素3时，
在元素3后边添加新的元素8，最后把剩余的元素添加到元素
8的后面即可。
>>>>>> 链表 <<<<<<<
链表特点: 查询慢,增删慢---------与数组相反
链表:
由链子连接起来的一堆节点
结点:
地址值,值,下一个结点地址值
如何获取结点8 ?
没有什么好的地方,只能遍历链表,然后一个一个查看
要在结点2后边添加一个新的节点 8?
把结点2的下一个结点地址修改为新节点8的地址值,把结点8的下一个地址
修改为0x0033
图片在桌面-----
------------------------------
>>>>>>>> 栈和队列 <<<<<<<<
栈:
先进后出
队:
先进先出
------------------------------
>>>>>>> List <<<<<<<
/*
* List:
* 有序的(存储和读取的顺序是一致的)
* 有整数索引
* 允许重复的
*
* List的特有功能: 增删该查
* void add(int index,E element)//在指定位置添加元素,原位置的元素后移一位
* E get(int index)
* E remove(int index) //删除指定元素,并返回被删除的元素
* E set(int index,E element) //将制定索引位置的元素替换为指定元素,并将原先的元素返回
*
*/
public class List_Test {
public static void main(String[] args) {
//创建的列表对象
List list = new ArrayList();
Student s1 = new Student();
Student s2 = new student();
//在指定位置添加元素,原位置的元素后移一位
//void add(int index,E element);
list.add(0,"hello");
list.add(0,"word");
list.add(1,"java");
list.add(3,ss);
/*
* 添加后三个元素的排列位置
* 0,word-- 1,java-- 2,hello
* word 加入后 hello移动到1的位置
* 然后java加入到1的位置,hello由1的位置后移到2的位置
*/
//E get(int index)根据索引返回元素
System.out.println(list.get(0));
//使用时注意索引超限的情况
//E remove(int index);
//删除指定元素,并返回被删除的元素
Object s = list.remove(0);
//E set(int index,E element);
//将制定索引位置的元素替换为指定元素,并将原先的元素返回
//也可以直接打印list,因为list中存储的是String字符串
System.out.println(list);
}
}
---------------
>>>>>>>>> List 类的特有方法介绍: <<<<<<<<<
/*
* List的常用子类:
* ArrayList
* 底层是数组结构,查询快,增删慢
* LinkedList
* 底层结构是链表,查询慢,增删快
* 如何选择使用不同的集合?
* 查询多,增删少,用ArrayList
* 查询少,增删多,用LinkedList
* 如果不知道就使用ArrayList
* LinkedList 类
* 还为在列表的开头及结尾 get、remove 和 insert 元素
* 提供了统一的命名方法。这些操作允许将链接列表用作堆栈、队列
* 或双端队列。
* LinkedList的特殊用法:
* void addFirst(E e)添加到0为
* void addLast(E e)添加到size()-1位
* E getFirst() 获取0为元素
* E getLast() 获取size()-1元素
* E removeFirst() 删除0为元素
* E removeLast() 删除size()-1元素
*
*这些特有方法有什么用呢?
* 可以模仿栈和队列的结构,先进先出,后进先出
* 栈:先进后出
* 队列:先进先出
*/
public class List_Test_2 {
public static void main(String[] args) {
//创建List对象
LinkedList list = new LinkedList();
list.add("hello");
list.add("world");
//-------方法演示-----------
//void addFirst(E e):
//将元素添加到索引为0的位置
//void addLast(E e):
//将元素添加到索引为size()-1的位置(也就是最后)
list.addFirst("java");
list.addLast("android");
//运行后在内存中的顺序
//[java, hello, world, android]
//E getFrist():获取索引为0的元素
//E getLast():获取索引为size()-1的元素
//[java, hello, world, android]
System.out.println(list.getFirst());
//打印为 java
System.out.println(list.getLast());
//打印为 android
//E removeFirst():
//删除索引为0的元素,并返回被删除的元素
//E removeLast():
//删除索引为size()-1的元素,并返回被删除的元素
System.out.println(list.removeFirst());
//打印为 java
System.out.println(list.removeLast());
//打印为 android
System.out.println(list);
}
}
----------------------------------------
第七天
>>>>>> System.out.println() 解释<<<<<<
out 为在System类 里边 创建的printStream类的 对象
------流程:
System类中: 声明out对象
public final static PrintStream out = null;
|
PrintStream类中: out调用print(Object obj)方法
public void print(Object obj) {
write(String.valueOf(obj));
}
|
String类中: 调用String类的valueOf(Object obj)方法
public static String valueOf(Object obj) {
return (obj == null) ? "null" : obj.toString();
}
Object类中: obj不为空的话调用Object的toString()方法
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
//打印对象的
String toString(); //返回该对象的字符串表示
return getClass().getName()+"@"+integer.Intefer.toHexString（hasCode()）;
getClass():返回一个字节码对象;
Integer.toHexString():返回指定参数的十六进制字符串形式
hashCode():返回该对象的哈希码值(也就是内部地址)
--------------------------------------
<><><<><< 小数点位数控制 <><><><><>
package com.jiuye_zikan_day04;
import java.text.DecimalFormat;
public class Test01 {
public static void main(String[] args) {
Circle c = new Circle(5);
double circumference = c.circumference();
double area = c.area();
//限制小数点位数
//第一种方法 会四舍五入
// double a =(Math.round(1.12345*10000)/10000.0);
// System.out.println(a);
//第二种 会四舍五入
// DecimalFormat df = new DecimalFormat("#.###");
// area = Double.parseDouble(df.format(area));
//第三种 会四舍五入
area = Double.parseDouble(String.format("%.4f", area));
circumference = Double.parseDouble(String.format("%.4f", circumference));
//第四种
//太长
System.out.println("PI="+c.PI+"周长="+circumference+"面积="+area);
/*
int bb = (int)1.5;//强转不会四舍五入
System.out.println(bb);
*/
}
}
-----------------------------------------------
>>>> 查看 HashSet 的add()方法不能去重的原因--02<<<<
package com.jobday07;
import java.util.HashSet;
public class SetReapet_2 {
public static void main(String[] args) {
//创建集合对象
HashSet<Person> hs = new HashSet<Person>();
//创建元素对象
Person s1 = new Person("zhaoliu",455);
Person s2 = new Person("lisi",456);
Person s3 = new Person("lisi",456);
//添加
hs.add(s1);
hs.add(s2);
hs.add(s3);
//遍历
for(Person person : hs){
System.out.println(person);
}
}
}
class Person {
String name;
int age;
Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person [name="+name+",age="+age+"]";
}
//重写equals方法
@Override
public boolean equals(Object obj) {
System.out.println("-----------------");
//为了提高安全性需要对对传进来的对象进行判断,是否是
//同一种类型
//提高效率
if(this==obj){
return true;
}
//提高健壮性,避免向下转型时出现错误
if(this.getClass()!=obj.getClass()){
//判断字节码对象是否相同,不同的话说明类型不同
//也就不用往下判断了
return false;
}
Person s = (Person)obj;
//向下转型,可以获取子类特有成员
//比较年龄是否相等,如果不等则返回false
if(this.age!=s.age){
return false;
}
//比较姓名是否相等,如果不等则返回false
if(this.name!=s.name){
return false;
}
//默认返回true,说明两个学生是相等的
return true;
}
@Override
public int hashCode() {
/*
* 我们发现当hashCode方法永远返回整数1时,所有对象的hash值都是一样的,
* 有一些对象它的成员变量完全不同,但是他们还需要进行hash和equals方法的比较,
* 如果我们可以让成员变量不同的对象,他们的hash值也不同,这就可以减少一部分的equals
* 方法的比较,从而提高我们程序的效率
*
* 可以尝试着让hashCode方法的返回值和对象的成员变量有关
* 可以让hashCode方法返回所有成员变量之和
* 让基本数据类型直接相加,然后引用数据类型获取hashCode方法返回值后再相加(boolean可
* 以不参与运算,如果想参与运算的话可以让true代表一个值,false代表一个值)
*
*/
//return 1;
return age+name.hashCode();
//将返回值变成这种时,虽然运行结果一样,但是运行效率高了,
//因为大部分在比较hash值时就判断出是否相同了,减少了调用equals()
//方法的使用次数.
}
}
//hashCode()和equals()方法可以自动生成,不需要每次都手写
//而且自动生成的hashCode()和equals()方法写的更健壮
-----------------------------------------------------
>>>>>>>>>> HashSet存储字符串并遍历 <<<<<<<<<<<
package com.jobday07;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
/*
* 使用HashSet存储字符串并遍历
* Set集合的特点:
* 无序(存储和读取的顺序有可能不一样)
* 不允许重复(要求元素唯一)
* 没有索引
* 遍历方法:
* 1.迭代器
* 2.增强for
*
* add(E e) 如果 set 中尚未存在指定的元素，则添加此元素（可选操作）。
*
*/
public class Set_Test {
public static void main(String[] args) {
//创建集合对象
//HashSet<String> hs = new HashSet<String>();
Set<String> set = new HashSet<String>();
//父接口引用指向子类对象
//添加元素对象
set.add("hello");
//set.add("word");
System.out.println(set.add("java"));
//打印 true
System.out.println(set.add("java"));
//打印 false ,应为HashSet不允许添加重复元素
//遍历集合对象
//collection 有三种
//List 有四种,多一个普通for循环
//转数组
Object[] objs = set.toArray();
for(int i=0;i<objs.length;i++){
System.out.println(objs);
}
//迭代器
Iterator<String> it = set.iterator();
while(it.hasNext()){
String s = it.next();
System.out.println(s);
}
//增强for
for(String str : set){
System.out.println(str);
}
}
}
------------------------------------------
>>>>>>>>>>> Map <<<<<<<<<<<
package com.jobday07;
/*
* 需求:实现学号的和姓名这样有对应关系的数据存储
* 为了体现这种有对应关系的数据,我们使用以前学的内容是可以实现的,但是略有不便,所以java
* 又给我提供了一种专门用于存储对应关系的集合,Map
*
* Map:将键映射到值的对象.一个映射不能包含重复的键;每个键最多只能映射到一个值
*
* Map和Collection有什么区别?
* Map:是一个双列集合,常用于处理对应关系的数据,key是不可以重复的,我们也称之为是夫妻对集合
* Collection:是单列集合,Collection有不同的子体系,有的允许重复有索引有序(List),有的不允
* 许重复而且无序(Set),那么我们也称之为单身汉集合
* 一对一:一个学号对应一个姓名
*/
public class Map_Test {
public static void main(String[] args) {
}
}
-----------------------------------------------
>>>>>>> Map 的方法演示 01<<<<<<
package com.jobday07;
import java.util.HashMap;
import java.util.Map;
/*添加功能:(添加/覆盖)
* V put(K key, V value)
将指定的值与此映射中的指定键关联（可选操作）。
* 获取功能:
* V get(Object key)
* int size()
* 判断功能:
* boolean containsKey(Object key)
* boolean containsValue(Object value)
* boolean isEmpty()
* 删除功能:
* void clear()
* v remove(Object key)
* 遍历功能:
* Set<Map.Entry<K,V>> entrySet()
*
* Set<K> keySet()
* 返回此映射中包含的键的 Set 视图。
*/
public class Map_function {
public static void main(String[] args) {
//创建Map对象
Map<String,String> map = new HashMap<String,String>();
//映射(添加,修改)
//V put(K key,V value):就是将key映射到value,如果key存在,
//则覆盖value,并将原来的value返回
System.out.println(map.put("ITCAST001", "张三"));
System.out.println(map.put("ITCAST002", "李四"));
System.out.println(map.put("ITCAST001", "王五"));
System.out.println(map);
//打印结果:
//null
//null
//张三
//{ITCAST002=李四, ITCAST001=王五}
/*解析:
* 两个null是在添加ITCAST001,002时返回的
* 张三是在第三次添加"ITCAST001,王五"时返回的
* "ITCAST001,王五"将ITCAST001对应的张三替换掉了
* 所以返回了张三
* 所以put方法不仅有添加的功能还有替换的功能
*/
//booleam containsKey(Object key) :判断指定key是否存在
//System.out.println(map.containsKey("ITCAST003"));
//打印结果:false
//boolean containsValue(Object value):判断指定的
//System.out.println(map.containsValue("王五"));
//打印结果: true
//void clear() 清空集合
//map.clear();
//boolean isEmpty(); 如果此映射未包含键-值映射关系，则返回 true。
//System.out.println(map.isEmpty());
//打印结果:true
//因为上边使用了clear()方法,将集合内容进行了清空,
//所以isEmpty()方法返回true
//V remove(Object key)
//根据指定的key删除对应的关系,并返回key所对应的值,如果没有删除成功返回null
System.out.println(map.remove("ITCAST001"));
//打印结果:王五
//因为删除了"王五"所以返回王五
System.out.println(map);
//打印结果:{ITCAST002=李四}
//v get(Object key) :跟据指定的key返回对应的value
System.out.println(map.get("ITCAST002"));
//打印结果:李四
}
}
---------------------------------------------------
>>>>>>>Map 中 entrySet() 方法的使用 <<<<<<<<
package com.jobday07;
/*
* Map:
* entrySet() 方法的使用:
* 方便将Map集合中的key和value 一块迭代出来
*/
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
public class Map_entrySet {
public static void main(String[] args) {
Map<String,Stu> mm = new HashMap<String,Stu>();
Stu s1 = new Stu("小明",5);
Stu s2 = new Stu("大鹏",6);
Stu s3 = new Stu("叮当",3);
// Stu s3 = s2;
mm.put("001", s1);
mm.put("002", s2);
mm.put("003", s3);
Iterator iter = mm.entrySet().iterator();
while(iter.hasNext()){
Map.Entry<String,Stu> entry = (Map.Entry)iter.next();
System.out.println(entry.getKey()+"--"+entry.getValue());
}
}
}
class Stu{
String name;
int age;
public Stu(String name, int age) {
this.name = name;
this.age = age;
}
}
---------------------------------------
>>>> Map 中 keySet()/ values() 方法使用 <<<<
*
* Set<K> keySet()
* 返回此映射中所包含的键的 Set 视图(Set集合)
* Collection<V> values()
* 返回此映射所包含的值的 Collection 视图(Collection集合)
*/
public class Map_function02 {
public static void main(String[] args) {
//创建Map对象
AbstractMap<String,String> map = new HashMap<String,String>();
//Map<String,String> map = new HashMap<String,String>();
//添加映射
map.put("ITCAST001","zhansan");
map.put("ITCAST002","lisi");
map.put("ITCAST003","wangwu");
//Set<K> keySet()
//以Set形式返回
Set<String> set = map.keySet();
System.out.println(set);
//打印结果:[ITCAST002, ITCAST003, ITCAST001]
//Collection<V> values()
Collection coll = map.values();
System.out.println(coll);
//打印结果:[lisi, wangwu, zhansan]
System.out.println(map.toString());
}
}
------------------------------------------------
>>>>> Map 的 遍历 <<<<<<<
展示了两种:
/*
* Map的第一种遍历方式:
* 首先获取所有的key
* 遍历所有的key
* 获取每一个key
* 通过key去获取对应的value
*/
public class Map_遍历 {
public static void main(String[] args) {
//创建集合对象
Map<String,String> map = new HashMap<String,String>();
map.put("001", "小明");
map.put("002", "路飞");
map.put("003", "大鹏");
//获取所有的键(key)
Set<String> keys = map.keySet();
//遍历key,获取每一个对应的值(value)
for(String key : keys){
String value = map.get(key);
System.out.println(key+"--"+value);
}
/*打印结果:
* 001--小明
* 002--路飞
* 003--大鹏
*/
}
}
-------第二种遍历 更倾向于面向对象-------
注意:
其实Map.Entry<K,V>是Map 的内部类
/*Map的第二种遍历方式:
* 通过Entry(映射关系)对象获取key和value
* class Entry<K key,V value>{
* K key;
* V value;
* public Entry(K key,V value){
* this.key = key;
* this.value = value;
* }
* public K getKey(){
* return key;
* }
* public V getValue(){
* return value;
* }
* }
* 映射关系获取方法:
* Set<Map.Entry<K,V>> entrySet()
* 返回此映射中包含的映射关系的 Set 视图。
*/
public class Map_Entry遍历 {
public static void main(String[] args) {
Map<String,String> mm = new HashMap<String,String>();
mm.put("001", "苹果");
mm.put("002", "橘子");
mm.put("003", "香蕉");
//增强for 循环遍历 ----- 1
Set<Map.Entry<String,String>> entrys = mm.entrySet();
//遍历包含了映射关系对象的集合
for(Map.Entry<String,String> entry : entrys){
String key = entry.getKey();
String value = entry.getValue();
System.out.println(key+"--"+value);
}
/*
* 打印结果 :001--苹果
* 002--橘子
* 003--香蕉
*/
//Iterator 迭代遍历----2
Iterator iter = mm.entrySet().iterator();
//利用entrySet()方法返回的是一个Set集合,所以可以直接
//调用Set集合的iterator()方法获得一个Set迭代器对象
while(iter.hasNext()){
Map.Entry<String,String> entry2 =(Map.Entry<String,String>)iter.next();
String key2 = entry2.getKey();
String value2 = entry2.getValue();
System.out.println(key2+"--"+value2);
}
/*
* 打印结果 :001--苹果
* 002--橘子
* 003--香蕉
*/
}
}
-----------------------------------------------------------------
>>>>>>> HashMap 的遍历 <<<<<<<<<
1.使用字符串作为key 时的遍历
2.使用自定义对象作为key 时的遍历
/*
* 1 使用hashMap存储数据并遍历(使用字符串作为key)
*/
public class HashMap_存储及遍历 {
public static void main(String[] args) {
//创建Map对象
HashMap<String,String> hm = new HashMap<String,String>();
//添加映射关系
hm.put("001","苹果");
hm.put("002","香蕉");
hm.put("003","橘子");
hm.put("003","橙子");
//遍历
//方式1 获取所有的key,通过key获取value
Set<String> keys = hm.keySet();
for( String key : keys){
String value = hm.get(key);
System.out.println(key+"--"+value);
}
//方式2 : 获取所有的映射关系对象,然后通过映射关系对象获取key和value
Set<Map.Entry<String, String>> entrys = hm.entrySet();
for(Map.Entry<String,String> entry : entrys){
String key = entry.getKey();
String value = entry.getValue();
System.out.println(key+"--"+value);
}
/*打印结果:
* 001--苹果
* 002--香蕉
* 003--橙子
*003的橘子被最后的003的橙子给覆盖了
*/
}
}
============
/*
* 2 使用hashMap存储数据并遍历(使用自定义对象作为key)
*/
public class HashMap_遍历2 {
public static void main(String[] args) {
//创建Map对象
HashMap<Student2,String> hm = new HashMap<Student2,String>();
//创建key对象
Student2 s1 = new Student2("zhangsan",18);
Student2 s2 = new Student2("zhangsan",18);
Student2 s3 = new Student2("lisi",20);
//添加成员
hm.put(s1, "001");
hm.put(s2, "002");
hm.put(s3, "003");
//遍历Map对象
//方式1: 获取所有的key,通过key来获取value
Set<Student2> keys = hm.keySet();
for(Student2 key : keys){
String value = hm.get(key);
System.out.println(key+"--"+value);
}
// 打印结果:
// Student2 [name=zhangsan, age=18]--002
// Student2 [name=lisi, age=20]--003
// Student2 [name=zhangsan, age=18]--001
/*解析:1.因为重写了Student2的toString方法所以可以打印出[name=lisi, age=20]
* 如果补重写的话就会输出字节码对象加地址
* 2.两个zhangsan 都加到了集合中,是因为,key使用的是自定义对象(Student2对象),
* 因为每个对象的哈希值不同所以都加进去了(可以查看put()方法),如果想让对象内成员
* 属性一样的不重复添加,就要重写Student2类中的hashCode()和equals()方法,
* Student2类的对象的hash值都一样,然后就可以进行内容的判断了.
*/
//方式2 获取所有的映射关系对象,通过映射关系对象获取key和value
Set<Map.Entry<Student2,String>> entrys = hm.entrySet();
for(Map.Entry<Student2,String> entry : entrys){
Student2 key = entry.getKey();
String value = entry.getValue();
System.out.println(key+"--"+value);
}
// 打印结果:
// Student2 [name=zhangsan, age=18]--002
// Student2 [name=lisi, age=20]--003
// Student2 [name=zhangsan, age=18]--001
}
}
class Student2{
String name;
int age;
public Student2(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Student2 [name=" + name + ", age=" + age + "]";
}
}
---------------------------------------------------
>>>>>>>>>>>>> 可变参数 <<<<<<<<<<<<<<
package com.jobday07;
/*
* 需求:定义一个方法,参数为两个int类型的变量,对参数求和并返回
* 定义一个方法,参数为三个int类型的变量,对参数求和并返回
* ...
*
* JDK1.5特性
* 可变参数:当参数不确定的时候,类型要明确,Java可以把多个参数直接
* 帮我们转换成数组
*
* 实参: 一个参数一个参数的传递
* 形参: 类型...变量名
*
* 注意:
* 1.在可变参数之后不可再追加参数
* 2.参数的数量自定义,可以给多个,甚至也可以一个都不给
* 3.使用可变参数的方法时也可以进行方法重载,但是使用时,
* 其它参数的数据类型要与可变参数的数据类型不同;
* 例:
* 方法调用:result = sum(1,2,3,4,5);
* 方法定义:public static int sum(int...arr){}
*
* 解析:
* 1.在可变参数之后不可再追加参数
* 例:
* public static int sum(int...arr,int a){}//错误
* 不可以在可变形参的后边添加形参
* public static int sum(int a,int...arr){}//正确
* 在可变形参的前边添加形参是可以的
* 2.参数的数量自定义,可以给多个,甚至也可以一个都不给
* 例:
* 方法调用:result = sum();
* 方法定义:public static int sum(int...arr){}
* 调用方法的时候不传参数也是可以的
* 3.使用可变参数的方法时也可以进行方法重载,但是使用时,
* 其它参数的数据类型要与可变参数的数据类型不同;
* public static void main(String[] args) {}
* public static int sum(String a,int...arr){}
*
*/
public class 可变参数 {
public static void main(String[] args) {
int result = sum(1,2,3,4,5);
}
//定义可变行参方法,进行求和 , 只有可变形参的求和方法 1
public static int sum(int...arr){
int result = 0;
for(int i=0;i<arr.length;i++){
result += arr;
}
return result;
}
//有一个可变行参,和多个其它形参的方法
public static int sum(String a,int...arr){
// int result = a;
int result = 0;
for(int i=0;i<arr.length;i++){
result += arr;
}
return result;
}
}
--------------------------------------------
>>>>>>>>>>> Map 嵌套 Map <<<<<<<<<<<<
package com.jobday07;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/*
* ithema:基础班,就业班
* 基础班:01 zhangsan; 02 lisi
* 就业班:01 wangwu; 02 zhaoliu
*
* 分析:
* 我们需要有班级和学生,班级和学生之间是一种对应关系(映射关系),
* 由于有对应关系,所以我们可也使用Map集合来存储这样的数据,
* 可以使用班级作为key,学生作为value,
* Map中的key只能对应一个value,但是我们一个班级中有多个学生,
* 我们创建一个包含多个学生信息的集合,让班级和这个集合产生一一对应的关系,
* 学生信息分为学号和姓名,这也是一种对应关系,所以我们使用Map集合来存储学生信息
*
* 学校Map
* 基础班 基础班学生Map
* 就业班 就业班学生Map
*
* Map嵌套Map
*/
public class Map嵌套Map_案例 {
public static void main(String[] args) {
//创建学校Map
Map<String,Map<String,String>> school = new HashMap<String,Map<String,String>>();
//创建基础班Map
Map<String,String> base = new HashMap<String,String>();
//添加学员信息
base.put("base001", "xiaoming");
base.put("base002", "dapeng");
base.put("base003", "zhubajie");
//创建就业班Map
Map<String,String> job = new HashMap<String,String>();
//添加学员信息
job.put("job001", "比克");
job.put("job002", "酷林");
job.put("job003", "天津饭");
//将班级Map添加到学校Map
school.put("基础班", base);
school.put("就业班", job);
//遍历班级学员
//1.获取学校的key
Set<String> schoolKeys = school.keySet();
//2.遍历学校班级
for(String schoolKey : schoolKeys){
//3.通过学校key获取班级value
Map<String,String> classesMap = school.get(schoolKey);
//4.获取班级的key(也就是key)
Set<String> classesKeys = classesMap.keySet();
//5.遍历通过班级key获取所有的学员信息
for(String classesKey : classesKeys){
//获取班级key对应的学员value
String student = classesMap.get(classesKey);
System.out.println(schoolKey+" "+classesKey+" "+student);
}
}
}
}
------------------------------------------------
>>>>>>>>>>Map 嵌套 Collection <<<<<<<<<<<
package com.jobday07;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
/*
* ithema:基础班,就业班
* 基础班:01 zhangsan; 02 lisi
* 就业班:01 wangwu; 02 zhaoliu
*
* 更为面向对象
*
* 学校Map
* 基础班 基础班学生List
* 就业班 就业班学生List
*
* Map嵌套Collectin
*
*/
public class Map嵌套Collection {
public static void main(String[] args) {
//创建学校Map
Map<String,List<Student1>> school = new HashMap<String,List<Student1>>();
//创建基础班,用List集合存储学员信息
List<Student1> base = new ArrayList<Student1>();
//添加基础班学员
base.add(new Student1("b001","xiaoming",18));
base.add(new Student1("b002","dapeng",16));
base.add(new Student1("b003","kulin",25));
//创建就业班学员,用List集合存储
List<Student1> job = new ArrayList<Student1>();
//添加就业班学员
job.add(new Student1("j001","酷林",21));
job.add(new Student1("j002","天津饭",22));
job.add(new Student1("j003","比克",26));
//将班级添加到学校Map
school.put("基础班", base);
school.put("就业班", job);
//遍历班级学生
//1 通过entrySet()获取学校Map中的班级映射关系对象的Set集合
Set<Map.Entry<String, List<Student1>>> schoolSet = school.entrySet();
//2遍历schoolSet集合,获取每一个Entry(映射关系对象)
for(Map.Entry<String, List<Student1>> schoolEntry : schoolSet ){
//2通过学校的映射关系对象获取班级名(key),和对应班级(value)
String classes = schoolEntry.getKey();
System.out.println("班级名:"+classes);
//3获s取班级学员信息,并遍历
List<Student1> students = schoolEntry.getValue();
for(Student1 student : students){
System.out.println(student);
}
}
//打印结果:
// 班级名:就业班
// Student1 [id=j001, name=酷林, age=21]
// Student1 [id=j002, name=天津饭, age=22]
// Student1 [id=j003, name=比克, age=26]
// 班级名:基础班
// Student1 [id=b001, name=xiaoming, age=18]
// Student1 [id=b002, name=dapeng, age=16]
// Student1 [id=b003, name=kulin, age=25]
}
}
//创建学生类
class Student1{
String id;
String name;
int age;
public Student1(String id, String name, int age) {
super();
this.id = id;
this.name = name;
this.age = age;
}
//重写toString方法,方便打印
@Override
public String toString() {
return "Student1 [id=" + id + ", name=" + name + ", age=" + age + "]";
}
}
-----------------------------------------------
第八天
>>>>>>>> 异常 <<<<<<<<<<
import java.io.FileWriter;
/*我们在写代码时,经常出现一些小问题,那么为了方便我们处理些问题,java为我们提供了异常机制
*
* 异常包含了错误的类型,原因以及位置
*
* 异常:不正常,我们写代码的时候出现的编译或者运行时的错误
*
* 下边的这个异常是运行 int a = 10/0;时抛出的,以它为例进行讲解
*
* Exception in thread "main" java.lang.ArithmeticException: / by zero
* at com.jobday08.异常概述_1.main(异常概述_1.java:12)
* 逐个单词解析:
* Exception :异常
* thread "main" :在主方法
* ArithmeticException :为异常时创建的对象,注意在编译时没有创建它的对象,在运行时才创建它的对象
* com.jobday08.异常概述_1.main :包名.类名.方法名
* (异常概述_1.java:12) :具体位置
* 在API中查看ArithmeticException类 该类的作用:当出现异常的运算条件时，抛出此异常
*
* 异常的顶层类为:Throwable类 :Throwable 类是 Java 语言中所有错误或异常的超类
*
* 异常的体系结构:
* Throwable类 (最顶层):有两个直接子类
* Error类(错误):出现的不能够处理的严重问题
* Exception类(异常):出现的是一些可以处理的问题
分为: 1.编译时异常,编译时期就会发生的异常
2.RuntimeExcetion 运行时异常
* 例: 电脑
* 系统中毒:重装系统就可以了(看成Exception)
* 主板坏了:买一台新的(看成Error)
*/
public class 异常概述_1 {
public static void main(String[] args) {
//运行时异常,举例---10/0是错误的但是在编译的时候没有问题
//在运行的时候才会抛出异常
int a = 10/0;
System.out.println(a);
//编译时错误,举例---此处会在运行前抛出一个IO异常(因为没有抛异常)
FileWriter fw = new FileWriter("a.txt");
}
}
---------------------------------
>>>>>>> 异常 的捕获 /抛出去 <<<<<<<
两种异常处理:
1.捕获异常 try...catch
2.抛出去 throws
/*
* 异常的处理方式:
* 1.捕获处理
* try...catch语句
*
* try{
* 有可能出现问题的代码;
* }catch(ArithmeticException ae/异常对象举例/){
* 处理异常;
* }
*
* try...catch的执行顺序:
* 1.如果发现异常,异常下面的代码不在执行,直接跳入catch语句
* 中,catch语句结束后,整个try...catch结束,继续执行下边的代码
程序不会停止运行.
* 2.如果没有发现异常,try语句执行结束后,try...catch直接结束,
* 不在执行catch语句;继续向下执行
* 2.抛出去
* 当我们不想处理异常,或者没有能力处理的时候,我们可以选择抛出异常,谁调用方法谁处
* 理异常,使用关键字throws在方法的声明处抛出异常.
*
* jvm处理异常的方式:
* 如果出现异常我们没有处理,jvm会帮我们进行处理,他会把异常的类型,原因,位置,显示在命令行,
* 并且还终止了程序,异常后面的代码将不再执行
*/
public class try_catch异常 {
public static void main(String[] args) throws Exception {
//try...catch语句的使用
method_1();
//调用方法
function();
//因为function()方法抛出了异常,所以
//调用它时也要抛出异常,原则是谁使用谁处理,最后异常
//会抛到虚拟机那,由jvm虚拟机来处理
}
public static void function() throws IOException{
FileWriter fw = new FileWriter("a.txt");
/*
* 此处需要抛出IO异常
* 通过查看FileWriter类的源码,它的构造函数抛出了异常
* 以下是FileWriter类的构造源码
* public FileWriter(String fileName) throws IOException {
* super(new FileOutputStream(fileName));
* }
*
* 在此处我们除了可以抛出throws IOException异常外,还可
* 以抛出IOException的父类异常Exception,如果此处抛
* 出了Exception异常,那么在main方法中也要抛出Exception异常,
* 如果此处抛出IOException异常,在main方法中可以抛出Exception,
* 抛出级别只可以往父类走或不变,但是不能缩小(降低)
*/
}
private static void method_1() {
try{
System.out.println(1); //第一句
System.out.println(2/0); //第二句
System.out.println(2); //第三句
}catch(ArithmeticException ea){
System.out.println("除数不能为0");//第五句
}
System.out.println("hello"); //第六句
//打印结果:
// 1
// 除数不能为0
// hello
/*解析:
* 当执行到第二句时发现异常,不在执行第三句
* 直接跳入catch语句执行第五句,执行完后
* try...catch语句执行结束,继续执行第六句
*/
}
}
-------------------------------------------
>>>>>>>> 多个异常的处理 <<<<<<<<<
package com.jobday08;
/*
* 如何处理多个异常:
* 1.可以使用多个try...catch语句
* 2.使用一个try和多个catch
*
* 多个catch之间的顺序:
* 1.多个catch之间可以有子父类
* 2.平级之间没有顺序关系
* 3.如果有子父类,父类异常必须放在后面,
* 因为放在前边的话,出现异常时就会被父类处理,
* 下边的子类语句就永远不会执行到,系统就会报错.
*
*/
public class 多个异常的处理 {
public static void main(String[] args) {
//多个try...catch语句,处理多个异常
method();
//使用一个try和多个catch,处理多个异常
method_2();
}
private static void method_2() {
//使用一个try和多个catch
try{
//空指针异常
String s = null;
System.out.println(s.length());
//数组越界
int[] a = new int[5];
System.out.println(a[8]);
//运算异常
System.out.println(2/0);
}catch(NullPointerException ea){
System.out.println("出现空指针");
}catch(ArrayIndexOutOfBoundsException ae){
System.out.println("出现数组越界");
}catch(Exception ae){
System.out.println("出现异常了");
/*此处使用了空指针异常和数组异常的父类Exception
* 来捕获其它未知的异常,为什么没有使用顶层类Throwable
* 的原因是,Throwable除了可以捕获所有异常外,还可以捕获
* 所有的Error(出现的不能够处理的严重问题),Error类的
* 异常,就算捕获类了也处理不了,所以捕获Error是没有意义的.
*/
}
}
private static void method() {
try{
String s = null;
System.out.println(s.length());
}catch(NullPointerException ea){
System.out.println("出现空指针异常");
}
try{
int[] a = new int[5];
System.out.println(a[8]);
}catch(ArrayIndexOutOfBoundsException ae){
System.out.println("出现数组越界");
}
}
}
------------------------------------------
>>>>>>>> Throwable_常用方法 <<<<<<<<<<
package com.jobday08;
/* Throwable 的常用方法:
* //返回异常的详细信息,没有返回null
* String getMessage(); //可以存到一个变量中,输出到前台,或日志文件中
* getMessage() 没用详细信息的异常返回null
//返回异常的类型和原因
* String toString(); //可以存到一个变量中
* //使用标准错误输出流打印异常信息
* void printStackTrace();
*
* try...catch快捷键:Surround with---->Try/catch Block
* 快捷键生成的catch(Exception e)方法的参数,用的是
* Exception(捕获全部异常),需要手动更改
* catch(){
* 默认生成e.printStackTrace();
* //使用标准错误输出流打印异常信息
* }
*/
public class Throwable_常用方法 {
public static void main(String[] args) {
try {
System.out.println(2/0);
} catch (ArithmeticException e) { //此处需要捕获一个运算异常
//String getMessage();
System.out.println(e.getMessage());
/*打印结果:
* / by zero
* 指出了异常信息
*/
//String toString()
System.out.println(e.toString());
/*打印结果:
* java.lang.ArithmeticException: / by zero
* 指出了异常类型和原因
*/
// void printStackTrace();
e.printStackTrace();
/*打印结果:
* java.lang.ArithmeticException: / by zero
* at com.jobday08.Throwable_常用方法.main(Thr
* owable_常用方法.java:23)
*/
}
try {
String s = null;
System.out.println(s.length());
} catch (NullPointerException e) {
System.out.println(e.getMessage());
//打印结果:null
System.out.println(e.toString());
//打印结果:
//java.lang.NullPointerException
e.printStackTrace();
//打印结果:
//java.lang.NullPointerException
//at com.jobday08.Throwable_常用方法.ma
//in(Throwable_常用方法.java:49)
}
/*在上边在获取控制指针异常时,只有e.getMessage()方
* 法输出了"null",另外两个没有输出异常原因"null",
* 但都捕获了异常,只是不显示
*/
}
}
----------------------------------------------------
>>>>>>>>> finally 用法 <<<<<<<<<<,
package com.jobday08;
import java.io.FileWriter;
import java.io.IOException;
/*
* finally:
* 组合try...catch使用,用于释放资源首位工作,无论try...catch语
* 句如何执行,finally的代码一定会执行;
*
* try{
* 有可能出现问题的代码;
* }catch(异常对象){
* 处理异常;
* }finally{
* 释放资源; //写一些必须要执行的代码,
* 清理垃圾;
* }
* 解析 为什么使用finllay:
* 以FileWriter为例, 用try...catch捕获
* FileWriter的IOException异常,就不用在
* 主方法处抛出异常了(throws IOException),
* 然后在写文件的时候出现了一个未捕获异常 /zero
* fw.write("java");
* System.out.println(2/0);
* fw.close();
* 这时由于没有对2/0运算错误进行捕获,程序执行到这就会停止,
* 2/0这行代码一下的代码fw.close();就不会在执行,造成前边
* 要写入的字符(或文件)不能写入到文本中,这时就要用到finally
* 了,finally{}语句不管前边怎样都会执行,那就可以把fw.close();
* 这种必须要执行的语句放到finally{}语句中,保证它的执行;
* 虽然使用finally后2/0以下的代码还是不会执行,但是程序执行到
* 2/0行代码出现错误,然后去执行finally中的代码,将finally中的
* 代码执行完后再结束程序;
*
*/
public class Finally_用法 {
public static void main(String[] args) {
FileWriter fw = null;
try {
fw = new FileWriter("a.txt");
fw.write("java");
fw.write("java");
System.out.println(2/0);
// fw.close(); //把这句话移到了finally{}语句中
System.out.println("fw.close()的下一句");//不执行
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
fw.close(); //执行
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("finally");//执行
}
System.out.println("zuihou");//不执行
}
//最后打印结果:
//finally
//Exception in thread "main" jav
//a.lang.ArithmeticException: / by zero
// at com.jobday08.Finally_用法.main(Finally_用法.java:45)
/*
* javajava也写入到了 a.txt 文件中
*/
}
----------------------------------------
## 异常的分类
package com.jobday08;
import java.io.FileWriter;
import java.io.IOException;
/*
* 异常的分类:
* 运行时期异常: RuntimeException的子类就是运行时期异常,
* 在编译期可以自由选择处理或者不处理;
* 编译时期异常: 是Exception的子类,非RuntimeException的子类,
* 在编译时期必需处理;
*
* 补充:
* RuntimeException 是Java虚拟机正常运行期间抛出的异常的超类;
* Exception 是异常的超类;(它指出了合理的应用程序想要捕获的条件)
* Error 错误的超类;(用于指示合理的应用程序不应该试图捕获的严重问题)
* Throwable 是所有异常和错误的超类 ;
*
*以下边的程序为例:
* 创建FileWriter对象时,有两种处理异常的方法
* 1.直接抛出异常 throws IOException
* 2.try...catch IO异常
* 该IO异常就属于编译时期异常,通过在API文档查看IOException类,
* 可以看出它继承与Exception类,而不是继承于RuntimeExceptio类;
*/
public class 异常的分类 {
public static void main(String[] args) {
try {
FileWriter fw = new FileWriter("a.txt");
} catch (IOException e) {
e.printStackTrace();
}
}
}
-------------------------------------------------
## 自定义异常
package com.jobday08;
/*
* 需求:写一个方法,接受考试成绩,如果考试成绩的范围在0-100之间则属于正常,否则属于异常
*
* throws : 处理异常的一种方式,把异常抛出,由调用者来处理
* throw : 制造异常的方式,并且结束方法
*
* 注意 : 如果抛出(throw)的是编译时期异常,必须在方法声明处抛出(throws)
*
* 如何自定义一个异常类呢?
* 非常简单,写一个类去继承Exception或者RuntimeException,然后实现多个构造即可
*
* 创建自定义异常并使用的思路:
* 定义一个运行时或编译时异常的子类,---然后在定义的符合判断条件中语句中制造该异常,
* ---然后用try...catch语句捕获会出现问题的代码,---定义catch的异常对象为
* 自定义异常的所继承的类的对象,---catch语句中通过getMseeage(),toString(),
* printStackTrace(),等方法获取异常信息.
*/
public class 自定义异常 {
public static void main(String[] args) {
//第1种
/*boolean flag = checkScore1(-10);
System.out.println(flag);
//打印结果:false*/
//第2中方法
// try {
// checkScore2(-10);
// } catch (Exception e) {
// // TODO Auto-generated catch block
// System.out.println(e.getMessage());
// //打印结果:null
// /* 解析: <这个输出对应的是checkScore2方法中输出RuntimeException
// * 运行时异常的代码进行的解析>
// * 输出null说明没有原因,查看getMessage()方
// * 法的源码,该方法的返回值是String(一个字符串),
// * 返回的变量为detailMessage,通ctrl+F键,
// * 搜索detailMessage变量的使用位置,该变量
// * 在Throwable的有参构造方法中,被传进来的一个字符串参数
// * message赋值,因此想让getMessage()输出信息,
// * 就要使用Throwable的有参构造,由于RuntimeException
// * 继承了Throwable,所以我们想调用Throwable的有参构造,
// * 只需要调用RuntimeException的有参构造就行,
// * RuntimeException("考试成绩不符合要求")
// */
// //当把方法throw new RuntimeException("考试成绩不符合要求");
// //写成这样时,打印结果为: 考试成绩不符合要求
// }
//
// //使用checkScore2方法中的编译时异常代码,查看运行效果
// //此处还要在main方法声明处抛出异常,才可以使用
// //checkScore2(150);
//
//使用自定义异常时(定义了一个编译时异常),
//需要在main方法处抛出异常
try {
checkScore2(-10);
} catch (Exception e) {
System.out.println("哈哈");
System.out.println(e.getMessage());
System.out.println("哈哈");
}
//打印结果:
// 哈哈
// 考试成绩不符合
// 哈哈
}
//考试成绩判断方法 1 普通方法
public static boolean checkScore1(int score){
//判断考试成绩是否符合范围,如果不符合则返回false
if(score<0||score>100){
return false;
}
//符合
return true;
}
// 2 使用抛出异常的方法
public static void checkScore2(int score) throws Exception{
//制造运行时异常
/*if(score<0||score>100){
//符合判断条件,抛出异常
throw new RuntimeException("考试成绩不符合要求");
//运行时异常对应上边的输出null的解析
}
System.out.println("考试成绩符合要求");*/
//制造编译时异常
/*if(score<0||score>100){
//符合判断条件,抛出异常
throw new Exception();
//如果是制造的编译时异常,则必须在方法声明处抛出异常
//运行时异常对应上边的输出null的解析
}
System.out.println("考试成绩符合要求");*/
//制造自定义异常
if(score<0||score>100){
//符合判断条件,抛出异常
throw new MyException("考试成绩不符合");
//如果是制造的编译时异常,则必须在方法声明处抛出异常
//运行时异常对应上边的输出null的解析
}
System.out.println("考试成绩符合要求");
}
}
//自定义自己的异常
//继承Exception,为编译时异常
//继承RuntimeExcetion,为运行是异常
class MyException extends Exception{
/*
* 通过source快捷键生成父类的构造方法,
* 里边可以生成很多构造方法,在这只生成
* 空参 , String参数的构造就行了,以后根据
* 实际生成就行
*/
public MyException() {
super();
// TODO Auto-generated constructor stub
}
public MyException(String message) {
super(message);
// TODO Auto-generated constructor stub
}
}
-----------------------------------------------
>>>>>>> 递归的概述 <<<<<<<
递归思路:
假定方法可以求出想要的结果,将其中的一个数据模糊化
package com.jobday08;
/*
* 需求:求5的阶乘
* 5! = 5 * 4 * 3 * 2 * 1;
* 5! = 5 * 4!;
* 4! = 4 * 3!;
* 3! = 3 * 2!;
* 2! = 2 * 1!;
* 1! = 1;
* n! = n * (n-1)!;
*
* 递归:把大问题拆成很多小问题,然后再把小问题拆成更多的小问题,
* 当我们把跟多的小问题解决了,小问题也解决了
* 随着小问题的解决,大问题也随之解决了
*
* 递归的使用:在方法本身不断的调用方法自己.
* 递归注意事项:
* 递归一定要有出口,否则会内存溢出;
* 递归次数不宜过多,否则会内存溢出;
* 解析为什么会内存溢出:
* 一但调用递归方法,就会将方法加载栈区,当方法执行到调用自身的命令
* 行时,就不暂时停止往下执行,而是去执行调用自身方法命令,再在栈区
* 加载一个新自身的方法去执行,然后每次执行到调用方法命令行,就会加载
* 执行新的方法,导致栈区,开的方法越来越多,只有等到出现有符合结束条件
* 的方法时,从该方法处逐个往回结束调用的方法到最后第一次调用的方法结束,
* 也就是递归次数多的情况下,内存的栈区会加载很多方法(其实就将循环调用的方
* 法全部展开,再从最后出现的方法处逐个关闭),占用大量的空间,或是展开时需要的
* 内存大于栈区的内存,将栈区内存占满(出现溢出);
*/
public class 递归概述 {
public static void main(String[] args) {
int data = 5;
data = JC(data);
}
//求一次阶乘的方法
public static int JC(int data){
if(data == 1){
return 1;
}else{
data = data * JC(data-1);
return data;
}
}
}
-----------------------------------------------
>>>>>>> 使用递归实现 斐波纳契列数 <<<<<<<<<
package com.jobday08;
/*
* 古典问题:有一对兔子,从出生后第三个月起每月生一对兔子,小兔子
* 长到第三个月后每月又生一对兔子,假如兔子不死,
* 问第二十个月兔子对数为多少?
* 1
* 1
* 1+1=2
* 1+1+1=3
* 2+2+1=5
* 3+2+3=8
* 5+5+3=13
* 8+5+8=21
* 13+13+8=34
* 21+13+21=55
*
* (n-1)+(n-2)
*
*/
public class 斐波那契列数 {
public static void main(String[] args) {
System.out.println(rabbit(20));
}
//
public static int rabbit(int mouth){
if(mouth==1){
return 1;
}else if(mouth==2){
return 1;
}else{
mouth = rabbit(mouth-1)+rabbit(mouth-2);
return mouth;
}
}
}
-----------------------------------------------
|
|
收藏
淘帖
踩
