基本API
1.Math
2.System
3.Runtime
1.含义
表示当前虚拟机的运行环境
2.方法
4.Object
1) 含义
是java中的顶级父类。所有类都直接或间接的继承于Object
2）成员方法
注意：Object类中的toString方法返回的是地址值，若要打印一个对象，想要看到属性的话，可以重写toString方法
public class Objectdemo {
public static void main(String[]args) {
Student s=new Student("zhangsan",18);
String str=s.toString();
System.out.println(str);
}
}
public class Student {
private String name;
private int age;
public Student (String name,int age)
{
this.name=name;
this.age=age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
public String toString()//通过重写tostring方法来显示对象的属性，若不重写打印出来的为地址值
{
return name+","+age;
}
}
Object中的equals方法比较的是地址值，而String中的equals方法比较的是内容，因为String对Object中的equals方法进行了重写
public class ObjectStringdemo {
public static void main(String[]args)
{
String str="abc";
StringBuilder sb=new StringBuilder("abc");
//因为equals方法是被str调用，则equals方法要看String类型中的
//而string类型中equals比较的是内容，但在比较之前会先判断参数（sb）类型是否为String
//若不是则直接返回false
System.out.println(str.equals(sb));//false
//因为equals方法是被sb调用，则equals方法要看StringBuilder类型中的,StringBuilder类型中没有重写该方法
//则会调用Object中的equals方法
//而Object类型中equals比较的是地址值
System.out.println(sb.equals(str));//false
}
}
5.Calendar
1）概述
2）常用方法
3）代码
import java.util.Calendar;
import java.util.Date;
public class Calendardemo {
public static void main(String[]args)
{
Calendar c=Calendar.getInstance();
System.out.println(c);
Date d=new Date(0L);
c.setTime(d);
System.out.println(c);
int y=c.get(Calendar.YEAR);
int m=c.get(Calendar.MONTH)+1;
int d1=c.get(Calendar.DAY_OF_MONTH);
int w=c.get(Calendar.DAY_OF_WEEK);
System.out.println(y+","+m+","+d1+","+getWeek(w));
}
public static String getWeek(int w)
{
String []arr= {"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};
return arr[w];
}
}
6.Date
1.概述
Date 类是一个JDK写好的javabean 类，用来描述时间，精确到毫秒。
利用空参构造创建对象，默认表示系统当前时间
利用有参构造创建对象，表示指定时间
2.代码
import java.util.Date;
import java.util.Random;
public class Datedemo {
public static void main(String[]args)
{ //算一年后的时间
Date d1=new Date(0L);
long time=d1.getTime();
System.out.println(d1);
System.out.println(time);
time=time+1000L*60*60*24*365;
d1.setTime(time);
System.out.println(d1);
//比较前后时间大小(对象不能直接进行比较,需要引入变量进行赋值)
System.out.println();
Random r=new Random();
Date d2=new Date(Math.abs(r.nextInt()));
long t1=d2.getTime();
Date d3=new Date(Math.abs(r.nextInt()));
long t2=d3.getTime();
d2.setTime(t1);
d2.setTime(t2);
System.out.println(d1);
System.out.println(d2);
if(t1>t2) {
System.out.println("前一个时间大");
}else {System.out.println("后一个时间大");}
}
}
SimpleDateFormat
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateSimpleDateformatdemo {
public static void main(String[]args) throws ParseException
{
Date d=new Date(0L);
//利用空参构造创建SimpleDateFormat对象，默认格式
SimpleDateFormat sdf =new SimpleDateFormat ();
String str=sdf.format(d);
System.out.println(str);
//利用带参构造创建SimpleDateFormat对象，指定格式
SimpleDateFormat sdf1 =new SimpleDateFormat ("y年M月d日 HH:mm:ss E ");
String str1=sdf1.format(d);
System.out.println(str1);
//日期格式转换
String str2="2023/11/11 ";
//解析成Date形式
SimpleDateFormat sdf2=new SimpleDateFormat("yyyy/MM/dd ");
Date d1=sdf2.parse(str2);
//格式化
SimpleDateFormat sdf3=new SimpleDateFormat("yyyy年MM月dd日");
String str3=sdf3.format(d1);
System.out.println(str3);
}
}
基本类型包装类
1.理解
用一个对象，把基本数据类型给包起来
2.获取Integer对象的方式
## 3.利用构造方法和静态方法获取Integer的对象及两种方法的区别
1)获取对象
2）区别
在使用静态方法时，系统会自动为在-128~127之间的数字创建对象，所以可直接进行内容的比较
而在该范围外，JDK会重新创建对象并进行返回，所以进行比较时，比较的是地址值
4.自动拆箱和自动装箱
自动装箱：基本数据类型会自动的变成其对应的包装类
自动拆箱：把包装类自动的变成其对象的基本数据类型
5.小结
6.Integer的成员方法
代码
public class Integerdemo {
public static void main(String []args)
{
String str1=Integer.toBinaryString(100);//十进制转二进制
String str2=Integer.toOctalString(100);//十进制转八进制
String str3=Integer.toHexString(100);//十进制转十六进制
System.out.println(str1+" "+str2+" "+str3);
int i=Integer.parseInt("123")+1;
System.out.println(i);
}
}
细节：1.在进行类型转换的时候，括号里只能是数字
2.八种包装类当中，除了Character，其他类都有parseXXX的方法
正则表达式
1.作用
（1）检验字符串是否符合规则
（2）在一段文本中查找满足要求的内容
2.转义字符
/:转义字符，改变后面那个字符原本的含义，使其变得普通
//:前面的/是转义字符，改变后面/原本的含义，将其变成普通的“/”
3.方法（字符类，预定义字符，数量词）
4.运用
集合
泛型
1.好处
2.细节
- 泛型中不能写基本数据类型
- 指定泛型的具体类型后，传递数据时，可以传入该类类型或者其子类类型
- 如果不写泛型，类型默认是Object
3.泛型类
1）格式
2）代码
public class MyArrayListdemo {
public static void main(String[]args)
{
MyArrayList<Integer> ml=new MyArrayList<>();
ml.add(123);
ml.add(456);
ml.add(789);
int i=ml.get(0);
System.out.println(i);
System.out.println(ml);
}
}
import java.util.Arrays;
public class MyArrayList<E> {
Object[] obj=new Object [10];
int size;
public boolean add(E e)
{
obj[size]=e;
size++;
return true;
}
public E get(int index)
{
return (E)obj[index];
}
public String toString()
{
return Arrays.toString(obj);
}
}
4.泛型方法
方法中参数类型不确定时
方案一：使用类名后面定义的泛型（所有方法）
方案二：在方法申明上定义自己的泛型（只有本方法能用）
1）格式
2)代码
5.泛型接口
1)格式
6.泛型的继承和通配符
1）继承
泛型不具备继承性，但是数据具备继承性
集合的体系结构
1.Collection（接口）
1）注意
Collection是一个接口，不能直接创建它的对象，只能创建它实现类（ArrayList）的对象
2）方法
3）细节
contains：底层依赖equals方法进行判断
如果集合中存储的是自定义对象，也想通过contains方法来判断是否包含，那么在javabean类中需要重写equals方法
Collection 的遍历
1）迭代器遍历
（1）解释
迭代器在java中的类是Iterator,迭代器是集合专用的遍历方式。
（2）方法
（3）注意事项
指针不复位的情况下，要继续第二次遍历集合，只能再次获得一个新的迭代器对象
（4）代码练习
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class 迭代器 {
public static void main(String []args)
{ //创建集合并添加元素
Collection<String> c=new ArrayList<>();
c.add("aaa");
c.add("bbb");
c.add("ccc");
//获取迭代器对象
//迭代器好比一个箭头,默认指向集合的0索引
Iterator<String> it= c.iterator();
//利用循环不断地获取集合中每一个元素
while(it.hasNext()) //判断集合中该处索引是否有元素
{
String str=it.next(); //获取元素,指针向下一个索引移动
System.out.println(str);
}
}
}
2.增强for遍历
（1）解释及格式
（2）细节
修改增强for中的变量，不会改变集合中原本的数据
(3) 代码练习
import java.util.ArrayList;
import java.util.Collection;
public class 增强for {
public static void main(String[]args)
{
Collection<String> c=new ArrayList<>();
c.add("aaa");
c.add("bbb");
c.add("ccc");
for (String s:c)
{
System.out.println(s);
}
}
}
Lamda 表达式的遍历
（1）代码范例
import java.util.ArrayList;
import java.util.Collection;
public class 增强for {
public static void main(String[]args)
{
Collection<String> c=new ArrayList<>();
c.add("aaa");
c.add("bbb");
c.add("ccc");
//格式
c.forEach(s->System.out.println(s));
}
}
2.Collection总结
单列集合
List
1.特点
有序：存和取的元素顺序一致
有索引：可以通过索引操作元素
可重复：存储的元素可重复
2.特有方法
注意：加入指定元素时，原来位置的元素往后移
remove方法：输出时，输出的为被删除的元素，并非是删除后的集合
3.代码
import java.util.ArrayList;
import java.util.List;
public class Listdemo {
public static void main(String[]args)
{
List<String> L=new ArrayList<>();
L.add("aaa");
L.add("bbb");
L.add("ccc");
System.out.println(L);//[aaa, bbb, ccc]
String s=L.remove(0);
System.out.println(s);//aaa
System.out.println(L);//[bbb, ccc]
}
}
4.五种遍历方式对比
5.遍历代码
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class 遍历 {
public static void main(String[]args)
{
List<String> L=new ArrayList<>();
L.add("aaa");
L.add("bbb");
L.add("ccc");
//迭代器遍历
System.out.println("1");
Iterator<String> i=L.iterator();
while(i.hasNext())
{
String s=i.next();
System.out.println(s);
}
System.out.println("2");
//增强for遍历
for(String s:L)
{
System.out.println(s);
}
System.out.println("3");
//Lamda表达式遍历
L.forEach(s->System.out.println(s));
System.out.println("4");
//普通for循环
for(int j=0;j<L.size();j++)
{
String s=L.get(j);
System.out.println(s);
}
//列表迭代器遍历
//额外添加了一个方法,在遍历过程中可以添加元素(而迭代器遍历时不能)
System.out.println("5");
ListIterator<String> it=L.listIterator();
while(it.hasNext())
{
String s=it.next();
if("bbb".equals(s))
{
it.add("qqq");
}
}
System.out.println(L);
}
}
ArrayList
1.底层原理
LinkedList
1.概述
2.特有方法(了解)
(了解）因为这些方法都可以用Collection和List中的方法替代
Set
1.特点
2.Set集合的实现类
set接口中的方法基本上与Collection的API一致
HashSet（底层哈希表）
1.底层原理
2.注意
Hashcode和equals方法比较的是地址值，因此需要重写
3.哈希表
1）哈希值
对象的整数表现形式
2）对象的哈希值特点
4.HashSet的问题
1）存和取的顺序为何不同
存的时候根据哈希值算出索引存储， 取的时候从前往后遍历数组及链表
2)为什么没有索引
一个数组索引只能表示一个链表，一条链表有多个数据，若是有索引，则无法判断到底取链表中的哪一个数据
3）HashSet怎么保证数据去重的（HashCode 和equals ）
Hashcode :利用Hashcode方法可以得到哈希值，就可以确定元素存储在哪个位置
equals：再利用equals方法比较属性值是否相同
LinkedSet
1.底层原理
TreeSet
1.特点
2.两种比较方式
本周总结
又双又叕一周过去了，学到了不少东西，java基础也已经学完了，这周考核也结束了，也意识到自己的不足，选择题一塌糊涂，看来也不能只看视频了，毕竟视频没有书本全面，不然还会发生考核的题目和自己学到的东西不太一样的情况，哭死
马上要开始前端的学习了，之前没学完的东西也只能慢慢补了，希望接下来的14天的前端学习中，能更好的了解到前端，这样也有助于以后分端的选择
希望下次的考核能让我有个满意的成绩，加油
扫一扫
5458
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
