目录
1、StringBuilder转String:( 用toString( )方法 )
2、String转StringBuilder: ( 用构造方法来转换 )
1、有抽象方法的类叫做抽象类 //没有方法体的方法叫抽象方法
6、增强for循环:目标:简化数组和Collection集合的遍历
案例:成绩排序,要求用TreeSet集合存储多个学生(姓名,语文成绩,数学成绩),并遍历该集合。要求:按照总分从高到底出现
1、IDE中ctrl+alt+l代码格式化
alt+insert可以选择生成构造方法
2、Random随机数
1、导包
import java.util.Random
2、创建对象
Random r = new Random();
3、获取随机数
int x = r.nextInt(10); //获取数据的范围是[0-10);
获取一个1-100的随机数
int x = r.nextInt(100) + 1;
3、数组
1、定义格式
数据类型[ ] 变量名 // int[ ] arr 定义了一个int变量的数组,数组名是arr;
数据类型 变量名[ ] // int arr[ ] 定义了一个int类型的变量,变量名称是arr数组;
2、动态初始化和静态初始化
动态初始化:数据类型[ ] 变量名 = new 数据类型[数组长度]; //int[ ] arr = new int[ 5 ];
静态初始化:数据类型[ ] 变量名 = new 数据类型[ ]{数据1,数据2,数据3,……}; //int[ ] arr = new int[ ] {1,2,3,......}; 简化格式:int[ ] arr = {1,2,3,......};
3、数组元素的输出:
(1) 循环输出
(2) Arrays.toString(arr)输出 //需要导包 import java.util.Arrays;
4、对象
创建对象
类名 对象名 = new 类名( ); //Person p = new Person( );
5、字符串
1、遍历字符串:
public char charAt( int index ) //返回指定索引处的char值,索引也是从0开始的
2、字符串长度:
字符串对象.length( );
数组的长度:
数组名.length;
6、StringBuilder
1、常用的构造方法:
public String StringBuilder( ); //创建了空白的字符串对象
public String StringBuilder( String str ); //根据传入的字符串创建字符串对象
2、StringBuilder的添加和反转方法:
//先创建StringBuilder对象
StringBuilder sb = new StringBuilder( );
sb.append( 任意类型 );返回的是对象本身
sb.reverse( ); 返回相反的字符序列
例子:
StringBuilder sb = new StringBuilder( );
sb.append( "hello" );sb.append( "world" );sb.append( "100" );
/* 因为append( )方法返回的是对象,所以也可以调用方法(链式编程):
sb.append( "hello" ).append( "world" ).append( "100" ); */
System.out.print( "sb:" + sb ); //输出的内容为 helloworld100
sb.reverse( );
System.out.print( "sb:" + sb ); //输出的内容为 011dlrowolleh
7、StringBuilder和String之间的转化
1、StringBuilder转String:( 用toString( )方法 )
例 StringBuilder sb = new StringBuilder( );
sb.append( "hello" );
String str = sb.toString( );
System.out.print( str ); //输出结果是hello
2、String转StringBuilder: ( 用构造方法来转换 )
例 String str = "hello";
StringBuilder sb = new StringBuilder( str );
System.out.print( sb ); //输出结果是hello
3、用StringBuilder实现一个字符串的倒序:
4、用StringBuilder实现一个字符串的拼接:
8、集合
1、集合:
import java.util.ArrayList //要先导包
ArrayList<E> array = new ArrayList<>( ); //E是指集合中的类型
2、集合的构造方法:
public ArrayList( ) //创建一个空的集合对象
public boolean add( E e ) //将指定的元素增加到此集合末尾
public void add( int index,E element ) //在此集合的指定位置插入指定的元素
3、集合的构造和添加:
4、集合的常用方法:
(1)public boolean remove( object o ) //删除指定元素,返回true或false
(2)public E remove ( int index ) //删除指定索引处的元素,返回删除的元素
(3)public E set( int index,E element ) //修改指定索引的元素,返回被修改的元素
(4)public E get( int index ) //返回指定索引处的元素
(5)public int size( ) //返回集合中元素的个数
5、存储学生类对象并遍历:
建立学生类:
将学生类添加到集合中并遍历:
9、继承
1、this和super关键字的用法
例子:
//学生类
public class student{
private String name;
private int age;
public student(){}
public student(String name,int age){
this.name = name;
this.age = age;
}
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
}
// Person类继承学生类
public class Person extends student {
public Person(){}
public Person(String name,int age){
super(name,age);
}
public void study(){
System.out.println("好好学习");
}
}
//测试类
public class work11{
public static void main(String[] args) {
Person p = new Person();
p.setName("小明");
p.setAge(15);
System.out.println(p.getName()+","+p.getAge());
p.study();
Person p1 = new Person("风清扬",20);
System.out.println(p1.getName()+","+p1.getAge());
p.study();
}
}
2、权限修饰符
3、状态修饰符:final(最终态)和static(静态)
10、多态
1、多态的前提和体现:
(1)、有继承/实现关系
(2)、有方法重写
(3)、有父类引用子类对象 // Animal animal = new Cat( );
2、多态中成员访问的特点:
3、多态中的向上转型和向下转型:
Animal a = new Cat( ); //向上转型
Cat c = ( Cat ) a; //向下转型
4、用多态实现猫和狗:
//测试类
public class work11{
public static void main(String[] args) {
Animal a = new dog();
a.setName("小白");
a.setAge(2);
System.out.println(a.getName()+","+a.getAge());
a.eat();
a = new dog("小黑",3);
System.out.println(a.getName()+","+a.getAge());
a.eat();
}
}
//动物类
public class Animal{
private String name;
private int age;
public Animal() {
}
public Animal(String name,int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void eat(){
System.out.println("动物吃东西");
}
}
//狗类
public class dog extends Animal{
public dog() {
}
public dog(String name, int age) {
super(name, age);
}
@Override //重写方法的注释
public void eat(){
System.out.println("狗吃骨头");
}
}
11、抽象类
1、有抽象方法的类叫做抽象类 //没有方法体的方法叫抽象方法
2、抽象类的特点:
3、抽象类的成员特点:
12、接口
1、接口的特点:
2、接口的成员特点:
13、内部类
内部类可以直接访问外部类的成员,包括私有
外部类要访问内部类的成员,必须创建对象
public class work11{
private int age = 10;
public class inter{
public void sout(){
System.out.println(age);
}
}
public void show(){
inter i = new inter();
i.sout();
}
}
1、内部类按照在类中定义的位置不同,可分为:
成员内部类和局部内部类
调用成员内部类
//测试类
public class work11{
public static void main(String[] args) {
Animal.inter a = new Animal().new inter();
a.sout();
Animal b = new Animal(); //如果内部类是私有的,只能通过这个方式访问
b.show();
}
}
//外部类和成员内部类
public class Animal{
private int age = 10;
public class inter{
public void sout(){
System.out.println(age);
}
}
public void show(){
inter i = new inter();
i.sout();
}
}
调用局部内部类
//测试类
public class work11{
public static void main(String[] args) {
Animal a = new Animal();
a.show();
}
}
//外部类和局部内部类
public class Animal{
private int age = 10;
public void show(){
class inter{
public void sout(){
System.out.println(age);
}
}
inter i = new inter();
i.sout();
}
}
调用局部内部类中的特例(匿名内部类)
//测试类
public class work11{
public static void main(String[] args) {
Animal a = new Animal();
a.sout();
}
}
//外部类和匿名内部类
public class Animal{
private int age = 10;
public void sout(){
inter i = new inter(){ //dog i = new dog(){
public void show(){
System.out.println("匿名内部类");
}
};
i.show();
i.show();
}
}
//接口
public interface inter {
void show();
}
/*
//抽象类
public abstract dog{
public abstract void show();
}
*/
2、匿名内部类在开发中的使用:
//接口
//测试类
public class work11{
public static void main(String[] args) {
Animal a = new Animal();
inter i = new Cat();
a.useinter(i);
a.useinter(new inter() {
@Override
public void show() {
System.out.println("猫可以跳高了");
}
});
}
}
//动物类
public class Animal{
public void useinter(inter i){
i.show();
}
}
//Cat类
public class Cat implements inter{
@Override
public void show() {
System.out.println("猫可以跳高了");
}
}
//接口
public interface inter {
void show();
}
//抽象类
//测试类
public class work11{
public static void main(String[] args) {
Animal a = new Animal();
dog d = new Cat();
a.useinter(d);
a.useinter(new dog() {
@Override
public void show() {
System.out.println("我是加菲猫");
}
});
}
}
//动物类
public class Animal{
public void useinter(dog d){
d.show();
}
}
//dog类
public abstract class dog {
public abstract void show();
}
//Cat类
public class Cat extends dog{
@Override
public void show() {
System.out.println("我是加菲猫");
}
}
14、异常
1、异常概述:
2、异常处理:
try...catch...处理
Throwable的成员方法:printStackTrace() getMessage() toString()
public class work11{
public static void main(String[] args) {
System.out.println("开始");
method();
System.out.println("结束");
}
public static void method(){
try {
int[] arry = {1, 2, 3};
System.out.println(arry[3]);
}catch (ArrayIndexOutOfBoundsException a){
// a.printStackTrace(); //打印异常的类型,原因,位置
System.out.println(a.getMessage()); //获取异常的原因
System.out.println(a.toString()); //获取异常的类型及原因
}
}
}
throws处理异常
3、自定义异常:
//测试类
import java.util.Scanner;
public class work11{
public static void main(String[] args) throws ScoreException{
Scanner sc = new Scanner(System.in);
System.out.println("请你输入分数:");
int score = sc.nextInt();
Teacher t = new Teacher();
t.show(score);
}
}
//老师类
public class Teacher {
public void show(int score) throws ScoreException{
if(score<0||score>100){
throw new ScoreException("你给的分数有误,分数应该在0-100之间");
}else{
System.out.println("分数正常");
}
}
}
//自定义异常类
public class ScoreException extends Exception{
public ScoreException(){}
public ScoreException(String message){
super(message);
}
}
throws和throw的区别:
15、集合的进阶
1、集合的体系结构:
2、Collection集合
import java.util.Collection;
import java.util.ArrayList;
public class work11{
public static void main(String[] args){
Collection<String> c = new ArrayList<>();
c.add("hello");
c.add("java");
System.out.println(c); //[hello, java]
}
}
Collection的常用方法:
//add增加元素
Collection<String> c = new ArrayList<>();
System.out.println(c.add("hello")); //true
c.add("hello");
c.add("java");
System.out.println(c); //[hello,hello, java]
//remove删除元素
//初始c中元素为[hello,hello, java]
c.remove("hello"); //删除元素hello
System.out.println(c.remove("hello")); //true
System.out.println(c); //[java]
//clear清空集合中的元素
c.clear();
System.out.println(c); //[]
//contains判断集合中是否有指定元素
//初始c中元素为[hello,hello, java]
System.out.println(c.contains("hello")); //true
System.out.println(c.contains("javaee")); //false
//isEmpty判断集合是否为空
//初始c中元素为[hello,hello, java]
System.out.println(c.isEmpty()); //false
c.clear();
System.out.println(c.isEmpty()); //true
//size用来返回集合元素的个数
//初始c中元素为[hello,hello, java]
System.out.println(c.size()); //3
c.clear();
System.out.println(c.size()); //0
3、集合的遍历:
创建迭代器:
Collection<String> c = new ArrayList<>(); Iterator<String> it = c.iterator();
import java.util.Iterator;
import java.util.Collection;
import java.util.ArrayList;
public class work11{
public static void main(String[] args){
Collection<String> c = new ArrayList<>();
c.add("hello");
c.add("world");
c.add("java");
Iterator<String> it = c.iterator();
while (it.hasNext()){
String s = it.next();
System.out.print(s+" "); //hello world java
}
}
}
4、Collection集合存储学生对象并遍历:
//测试类
import java.util.Iterator;
import java.util.Collection;
import java.util.ArrayList;
public class work11{
public static void main(String[] args){
//创建Collection对象
Collection<Student> c = new ArrayList<>();
//创建学生对象
Student s1 = new Student("风清扬",10);
Student s2 = new Student("苍老师",33);
Student s3 = new Student("小泽",34);
//把学生添加到集合中
c.add(s1);
c.add(s2);
c.add(s3);
//遍历集合
Iterator<Student> it = c.iterator();
while (it.hasNext()){
Student s = it.next();
System.out.println(s.getName()+","+s.getAge());
}
}
}
//学生类
public class Student {
private String name;
private int age;
public Student(){}
public Student(String name,int age){
this.name = name;
this.age = age;
}
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
}
5、List集合:有序,可重复
List集合特有的方法:
add(int index,E element) //在指定索引处添加元素
remove(int index) //删除指定索引处的元素,返回被删除的元素
set(int index,E element) //修改指定索引处的元素,返回被修改的元素
get(int index) //返回指定索引处的元素
用List集合存储学生对象并遍历
//测试类
import java.util.Iterator;
import java.util.ArrayList;
import java.util.List;
public class work11{
public static void main(String[] args){
//创建List对象
List<Student> c = new ArrayList<>();
//创建学生对象
Student s1 = new Student("风清扬",10);
Student s2 = new Student("苍老师",33);
Student s3 = new Student("小泽",34);
//把学生添加到集合中
c.add(s1);
c.add(s2);
c.add(s3);
//遍历集合
Iterator<Student> it = c.iterator();
while (it.hasNext()){
Student s = it.next();
System.out.println(s.getName()+","+s.getAge());
}
//for循环遍历
for(int i=0;i<c.size();i++){
Student ss = c.get(i);
System.out.println(ss.getName()+","+ss.getAge());
}
}
}
//学生类
public class Student {
private String name;
private int age;
public Student(){}
public Student(String name,int age){
this.name = name;
this.age = age;
}
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
}
并发修改异常:在使用迭代器遍历List集合时,不能使用add方法,否则会出现异常
List集合的特有迭代器:ListIterator
和Iterator迭代器不一样的地方:ListIterator可按照正反两个方向遍历集合,可以在遍历过程中通过迭代器向集合中添加元素
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class work11{
public static void main(String[] args){
//创建List对象
List<String> c = new ArrayList<>();
c.add("hello");
c.add("world");
c.add("java");
//正向遍历集合
ListIterator<String> lit = c.listIterator();
while (lit.hasNext()){
String s = lit.next();
System.out.print(s+" "); //hello world java
}
System.out.println();
//反向遍历集合
while (lit.hasPrevious()){
String s = lit.previous();
System.out.print(s+" "); //java world hello
}
System.out.println();
//遍历的时候通过ListIterator迭代器来增加元素
while (lit.hasNext()){
String s = lit.next();
if(s.equals("world")){
lit.add("javaee");
}
}
System.out.println(c); //[hello, world, javaee, java]
}
}
6、增强for循环:目标:简化数组和Collection集合的遍历
内部原理:Iterator迭代器
例子:
import java.util.ArrayList;
import java.util.List;
public class work11{
public static void main(String[] args){
//增强for循环对数组遍历的简化
int[] arry = {1,2,3};
for(int i:arry){
System.out.println(i);
}
System.out.println("----------");
String[] strArry = {"hello","world","java"};
for(String s:strArry){
System.out.println(s);
}
System.out.println("----------");
//增强for循环对Collection集合遍历的简化
List<String> l = new ArrayList<>();
l.add("hello");
l.add("world");
l.add("java");
for(String s:l){
System.out.println(s);
}
}
}
结果:
List集合存储学生对象并四种方式遍历:
import java.util.Iterator;
import java.util.ListIterator;
import java.util.ArrayList;
import java.util.List;
public class work11{
public static void main(String[] args){
List<Student> list = new ArrayList<>();
Student s1 = new Student("风清扬",10);
Student s2 = new Student("苍老师",33);
Student s3 = new Student("小泽",34);
list.add(s1);
list.add(s2);
list.add(s3);
//用ListIterator遍历
ListIterator<Student> lit = list.listIterator();
while(lit.hasNext()){
Student s = lit.next();
System.out.println(s.getName()+","+s.getAge());
}
System.out.println("----------");
//用Iterator遍历
Iterator<Student> it = list.iterator();
while(it.hasNext()){
Student s = it.next();
System.out.println(s.getName()+","+s.getAge());
}
System.out.println("----------");
//用for循环遍历
for(int i=0;i<list.size();i++){
Student s = list.get(i);
System.out.println(s.getName()+","+s.getAge());
}
System.out.println("----------");
//用增强for循环遍历
for(Student s:list){
System.out.println(s.getName()+","+s.getAge());
}
}
}
结果:
List集合子类的特点:
ArrayList: 查询快,增删慢
LinkedList:查询慢,增删快
例子:
import java.util.*;
public class work11{
public static void main(String[] args){
ArrayList<String> array = new ArrayList<>();
array.add("hello");
array.add("world");
array.add("java");
//迭代器遍历
Iterator<String> it = array.iterator();
while (it.hasNext()){
String s = it.next();
System.out.println(s);
}
System.out.println("----------");
//增强for循环遍历
for(String s:array){
System.out.println(s);
}
System.out.println("----------");
System.out.println("----------");
LinkedList<String> link = new LinkedList<>();
link.add("hello");
link.add("world");
link.add("java");
Iterator<String> kit = link.iterator();
while (kit.hasNext()){
String s = kit.next();
System.out.println(s);
}
System.out.println("----------");
//增强for循环遍历
for(String s:link){
System.out.println(s);
}
}
}
结果:
LinkedList集合的特有方法:
7、Set集合
import java.util.Set;
import java.util.Iterator;
import java.util.HashSet;
public class work11{
public static void main(String[] args){
Set<String> set = new HashSet<>();
set.add("hello");
set.add("world");
set.add("java");
set.add("java");
Iterator<String> it = set.iterator();
while (it.hasNext()){
String s = it.next();
System.out.println(s);
}
System.out.println("----------");
for(String s:set){
System.out.println(s);
}
}
}
结果:
7.1哈希值
7.2HashSet
import java.util.Iterator;
import java.util.HashSet;
public class work11{
public static void main(String[] args){
HashSet<String> hs = new HashSet<>();
hs.add("hello");
hs.add("world");
hs.add("java");
hs.add("java");
Iterator<String> it = hs.iterator();
while (it.hasNext()){
String s = it.next();
System.out.println(s); //world java hello
}
System.out.println("----------");
for(String s:hs){
System.out.println(s); //world java hello
}
}
}
用HashSet集合存储学生对象并遍历
7.3LinkedHashSet
import java.util.Iterator;
import java.util.LinkedHashSet;
public class work11{
public static void main(String[] args){
LinkedHashSet<String> hs = new LinkedHashSet<>();
hs.add("hello");
hs.add("world");
hs.add("java");
hs.add("java");
Iterator<String> it = hs.iterator();
while (it.hasNext()){
String s = it.next();
System.out.println(s); // hello world java
}
System.out.println("----------");
for(String s:hs){
System.out.println(s); // hello world java
}
}
}
7.4TreeSet
import java.util.Iterator;
import java.util.TreeSet;
public class work11{
public static void main(String[] args){
TreeSet<Integer> treeSet = new TreeSet<>();
treeSet.add(10);
treeSet.add(40);
treeSet.add(30);
treeSet.add(20);
treeSet.add(30);
Iterator<Integer> it = treeSet.iterator();
while (it.hasNext()){
int s = it.next();
System.out.println(s); // 10 20 30 40
}
System.out.println("----------");
for(Integer s:treeSet){
System.out.println(s); // 10 20 30 40
}
}
}
7.5自然排序Comparable的使用
//测试类
import java.util.TreeSet;
public class work11{
public static void main(String[] args){
TreeSet<Student> treeSet = new TreeSet<>();
Student s1 = new Student("xishi",20);
Student s2 = new Student("wangzhaojun",19);
Student s3 = new Student("diaochan",21);
Student s4 = new Student("yangyuhuan",22);
Student s5 = new Student("wuzetian",20);
Student s6 = new Student("yangyuhuan",22);
treeSet.add(s1);
treeSet.add(s2);
treeSet.add(s3);
treeSet.add(s4);
treeSet.add(s5);
treeSet.add(s6);
for(Student s:treeSet){
System.out.println(s.getName()+","+s.getAge())
/* 输出结果为
wangzhaojun,19
wuzetian,20
xishi,20
diaochan,21
yangyuhuan,22
*/
}
}
}
//学生类
public class Student implements Comparable<Student>{
private String name;
private int age;
public Student(){}
public Student(String name,int age){
this.name = name;
this.age = age;
}
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
public int compareTo(Student s){
int num = this.age - s.age;
int num2 = num == 0?this.name.compareTo(s.name):num;
return num2;
}
}
7.6比较器排序Comparator的使用
//测试类
import java.util.Comparator;
import java.util.TreeSet;
public class work11{
public static void main(String[] args){
TreeSet<Student> treeSet = new TreeSet<>(new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
int num = o1.getAge() - o2.getAge();
int num2 = num == 0?o1.getName().compareTo(o2.getName()):num;
return num2;
}
});
Student s1 = new Student("xishi",20);
Student s2 = new Student("wangzhaojun",19);
Student s3 = new Student("diaochan",21);
Student s4 = new Student("yangyuhuan",22);
Student s5 = new Student("wuzetian",20);
Student s6 = new Student("yangyuhuan",22);
treeSet.add(s1);
treeSet.add(s2);
treeSet.add(s3);
treeSet.add(s4);
treeSet.add(s5);
treeSet.add(s6);
for(Student s:treeSet){
System.out.println(s.getName()+","+s.getAge());
/* 输出结果为
wangzhaojun,19
wuzetian,20
xishi,20
diaochan,21
yangyuhuan,22
*/
}
}
}
//学生类
public class Student{
private String name;
private int age;
public Student(){}
public Student(String name,int age){
this.name = name;
this.age = age;
}
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
}
案例:成绩排序,要求用TreeSet集合存储多个学生(姓名,语文成绩,数学成绩),并遍历该集合。要求:按照总分从高到底出现
//测试类
import java.util.Comparator;
import java.util.TreeSet;
public class work11{
public static void main(String[] args){
TreeSet<Student> treeSet = new TreeSet<>(new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
int num = o2.getScore1() + o2.getScore2() - o1.getScore1() - o1.getScore2();
int num2 = num == 0?o1.getName().compareTo(o2.getName()):num;
return num2;
}
});
Student s1 = new Student("xishi",80,85);
Student s2 = new Student("wangzhaojun",90,92);
Student s3 = new Student("diaochan",88,88);
Student s4 = new Student("yangyuhuan",100,100);
Student s5 = new Student("aozetian",92,90);
Student s6 = new Student("yangyuhuan",100,100);
treeSet.add(s1);
treeSet.add(s2);
treeSet.add(s3);
treeSet.add(s4);
treeSet.add(s5);
treeSet.add(s6);
for(Student s:treeSet){
System.out.println(s.getName()+",语文成绩:"+s.getScore1()+",数学成绩:"+s.getScore2()+",总分:"+(s.getScore1()+s.getScore2()));
/* 输出结果为
yangyuhuan,语文成绩:100,数学成绩:100,总分:200
aozetian,语文成绩:92,数学成绩:90,总分:182
wangzhaojun,语文成绩:90,数学成绩:92,总分:182
diaochan,语文成绩:88,数学成绩:88,总分:176
xishi,语文成绩:80,数学成绩:85,总分:165
*/
}
}
}
7.7哈希表