Java类库是Java的应用程序接口(API),通常以包的形式组织类库
1、java.lang:默认导入的包,提供程序设计的常用基础类和接口;
2、java.util:工具类库,提供包含集合框架、集合类、日期时间等工具类;
3、java.io:Java的标准输入输出流;
4、java.applet:实现Java Applet 小程序的类库;
5、java.net:提供实现网络应用与开发的类库;
6、java.sql:提供访问并处理存储在数据源(通常是关系型数据)中的数据;
7、java.awt和java.swing:提供用户构建图形用户界面的类库;
8、java.awt.event:图形界面中用户交互控制和事件相应类库;
字符串String
使用构造方法创建String类的对象
1、String s=new String();//生成一个空字符串
2、String s=new String("Hello Wrold");//生成一个有参数的新字符串
3、char a[]={'a','b','c'}; String s=new String(a);//所得s=abc
4、char a[]={'a','b','c','d','e','f'} String s=new String(a,2,3);//s=cde //该处方法意思为,读取a的数组从下标为2开始读取,往后读三位
5、byte[] a={54,55,56}; String s=new String(a);//s='678'因为'6'的unicode码为54
6、byte[] a={54,55,56}; String s=new String(a,1,2);//s='78' //从下标1开始读取,往后读两位
String创建字符串对象区别:通过双引号自动创建的字符串对象存在于常量池,
通过构造方法创建的1字符串对象存在于堆内存;
String类中的成员方法
1、int n1="Hello World".length(); //获取字符串长度
2、String first=new String("ABC"); sec=new String("abc") boolean bol=first.equals(sec);//此时为false
3、String first=new String("ABC"); sec=new String("abc") boolean bol=first.equalsIgnoreCase(sec);//此时为true
4、String first="computer"; first.startWith("com");//返回true,是否以com为前缀
5、String first="computer"; first.endWith("ter");//返回true,是否以ter为后缀
6、public int compareTo(String s);//该方法是用来按照字典顺序对字符串进行比较
7、在String中用“==”比较判断两个字符串的引用是否相等,即地址是否相等
而equals方法比较两个字符串的内容是否相等
String s1="abc",s2="abc"; s1==s2;//返回结果为true,此时用双引号创建字符串,两次出现相同的字符串就不再创建新的对象,直接把s1的值赋给s2,因此你他们两个地址相同。
String s3=new String("abc"),s4=new String("abc"); s3==s4;//返回结果为false,因为s3和s4是通过构造方法创建的对象,所以引用不同,是两个不同的对象。而用s3.equals(s4)返回结果为true,因为内容相同。
8、public int indexOf(String s);//从第一个字符开始寻找s字串首次出现的位置,返回的是位置的序号
9、public String substring(int start,int ends);//返回start开始到end结束截取的字符串
10、public String replace(char oldChar,char newChar);//用新字符串代替旧字符串
11、String str="Hello",s="Wrold"; String kk=str.concat(s);//字符串拼接
12、public void getChars(int start,int end,char c[],int offset)://将字符串从start到end-1位置的字符复制到字符数组c中,并从c的第offset个位置开始存放这些字符。
public void toCharArray(); //将字符串中全部的字符复制到字符数组中,返回该数组的引用。
public byte[] getBytes(); //将字符串转成字符数组
public class CharacterDemo {
public void test(String str) {
//写一个方法并传一个字符串
char[] charArray=str.toCharArray();
//将传入的字符串复制给字符数组
for(int i=0;i<charArray.length;i++) {
if(Character.isDigit(charArray[i])){//判断指定的字符是否为数字
System.out.println(charArray[i]+"是数字");
continue;//如果是则当前循环跳出,进入下一次循环,判断下一个字符
}
if(Character.isLetter(charArray[i])) {
if(Character.isUpperCase(charArray[i])) {//判断指定的字符是否是大写字母
System.out.println(charArray[i]+"是一个大写字母");
}
else {
System.out.println(charArray[i]+"是一个小写字母");
}
continue;
}
System.out.println(charArray[i]+"不是数字也不是字母");
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
CharacterDemo cd=new CharacterDemo();
cd.test("HaFo 2023!");
}
}
13、public String[] split(String regex):返回基于regex拆分此字符串后形成的字符串数组
14、valueOf()方法用于将所传的值转为字符串
StringBuffer字符串
由于String定义的字符串是不可改变的,只要改变就会生成新的对象,这样非常耗费内存空间,所以提出可改变字符串缓冲类——StringBuffer类,该类可以多次增删改字符串内容而不产生新对象,每个StringBuffer对象都有初始容量,只要字符串长度不超过它的容量,就不需要再分配新的内部缓冲容量,否则容量自动增大。
StringBuffer的方法:
1、StringBuffer append(type x);//type可以是字符串、字符数组,向StringBuffer创建的对象中添加;
2、public StringBuffer reserve();//字符串反转
3、public int capacity();//获取缓冲区的大小;
public class StringBufferDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
StringBuffer sb=new StringBuffer();
sb.append(123);
sb.append("abc");
sb.append("de");
char x=sb.charAt(1);//索引从0开始,所以是‘2’
System.out.println("x="+x);
String temp1=sb.toString();
System.out.println("temp1="+temp1);
String temp2=sb.reverse().toString();//反转
System.out.println("temp2="+temp2);
}
}
日期类
Date类
1、public Date()无参构造方法,通过调用System的currentTimeMillis()方法来获取当前的时间戳,这个时间戳是从格林尼治时间1970年1月1日0时0分0秒到当前时间的1毫秒数;
2、public long getTime():可以将一个日期类型转换为long类型的数值,返回从格林尼治时间到Date对象所代表的时间之间经过的毫秒数;
3、public void setTime(long time):设置一个Date对象所代表从格林尼治时间到time毫秒的时间点;
4、public boolean before(Date when):判断Date对象所代表的时间点是否在when所代表的时间点之前 ;publi boolean after(Date when):判断Date对象代表的时间点是否在shen所代表的事件之前;
import java.util.Date;
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
Date now=new Date();//获取系统当前时间
Date when=new Date(10201020097865L);//定义指定的时间
boolean b1=now.after(when);//当前时间是否在when之后
boolean b2=now.before(when);//当前时间是否在when之前
Long d1=now.getTime(),d2=when.getTime();//获取时间的毫秒值
System.out.println("now的值为:"+now+"when的值为:"+when);
System.out.println("b1的值为:"+b1+"b2的值为:"+b2);
System.out.println("d1的值为:"+d1+"d2的值为:"+d2);
}
}
Calendar类
Calendar用于表示日历,用于对日期进行操作或运算,是被abstract修饰的抽象类,不能new一个对象,只能用成员方法getInstance()来得到一个Calendar对象
Calendar rightNow=Calendar.getInstance();
1、public void set(int year,int month,int date,int hour,int minute,int second):将该日历对象的年、月、日、小时、分钟、秒分别设置为year、month、date、hour、minute、second
2、public int get(int field):返回给定日历字段field的值 field可以取值为:Calendar.YEAR:表示年份; Calendar.MONTH:表示月份; Calendar.DAY_OF_MONTH:表示一个月中的某天; Calendar.HOUR:表示小时; Calendar.MINUTES:表示分钟; Calendar.SECOND:表示秒; Calendar.DAY_OF_YEAR:表示一年中的某天; Calendar.DAY_OF_WEEK:表示一个星期中的某天; Calendar.DAY_OF_WEEK_IN_MONTH:表示当前月中的第几个星期
import java.util.Calendar;
import java.util.Date;
public class CalendarDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
Calendar calendar=Calendar.getInstance();//现获得一个日历的对象
calendar.setTime(new Date());//将建立的Date对象传给calendar,且将long类型的毫秒数转换为时间点
System.out.println("现在的时间为"+new Date());
String year=String.valueOf(calendar.get(Calendar.YEAR));
String month=String.valueOf(calendar.get(Calendar.MONTH)+1);
//这个地方加1是因为月份是从0开始的,即一月=0
String day=String.valueOf(calendar.get(Calendar.DAY_OF_MONTH));
String week=String.valueOf(calendar.get(calendar.DAY_OF_WEEK)-1);
//这个地方减1的原因是,星期是从星期天到星期六,分别对应1-7,但是要从0开始计数为了让值转换为一个从0开始的索引
System.out.println("当前时间为"+year+"年"+month+"月"+day+"日,星期"+week);
long year2009=calendar.getTimeInMillis();//获得时间毫秒
calendar.set(1998,9, 26);//重新给calendar一个时间
long year1989=calendar.getTimeInMillis();//获得时间毫秒
long days=(year2009-year1989)/(1000*60*60*24);//毫秒做差后换算为天数
System.out.println("出生了"+days+"天");
}
}
包装类
由于六个基本数据类型没法创建对象,因此给六个基本数据类型封装成包装类;
Integer、Double、Character、Float、Byte、Long、Short;
Integer:
1、public Integer(int value):构造一个以value为值的Integer对象
2、public Integer(String s):将s转变为int型数据,并以该数据为值构造一个Integer对象;Integer i1=new Integer("99");即给"99"封装成Integer对象
3、public int intValue()//返回Integer对象对应的int值
4、public static Integer valueOf(int i);返回int 型参数i对应的Integer对象
5、public int compareTo(Integer anotherInteger):在数字上面比较两个Integer对象
字符串与数值转换:
1、public static byte parseByte(String s):字符串s转换为byte类型,此处的byte可以是short-parseShort、int-parseInt、long-parseInt、Float-parseFloat、float-parseFloat;
2、public static valueOf(type var):将type类型的变量var转化为字符串,type是八种数据类型都可以;
Character:
1、public static boolean isDigit(char ch):判断是否是数字;
2、public static boolean isLetter(char ch):判断是否是字母;
3、public static boolean isLLetterOrDigit(char ch):判断是否是数字和字母;
4、public static boolean isLowerCase(char ch):判断是否是小写字母;
5、public static boolean idUpperCase(char ch):判断是否是大写字母;
6、public static char toUpperCase(char ch):返回大写字母形式;
7、public static char toLowerCase(char ch):返回小写字母形式;
装箱与拆箱
装箱:把基本数据类型用对应的包装类封装起来;
拆箱:将包装类的对象重新转化为基本数据类型;
//手动装箱和拆箱
public class IntegerDemo{
public static void main(String[] args){
int i=0;
Integer j=new Integer(i);//手动装箱操作
int k=j.intValue();//手动拆箱操作
System.out.println(k*k);
}
}
//自动装箱和拆箱
public class IntegerDemo{
public static void main(String[] args){
Integer j=100;//将int数据自动转换成Integer对象
int k=j;//Integer对象自动转换为int数据
System.out.println(++k);
}
}
集合类
数组可以存储同一数据类型的数据,但是长度固定不变,不适合在数组元素数量未知的情况下使用,而集合可以,但是集合只能存放对象;集合存放的是对象的引用(即对象的地址),对象本身还是存放在堆内存中;集合元素数量是可改变的。
集合简介
Collections接口是集合层次框架的跟接口,是存储单一对象的集合(即每个位置保存的是单一的对象)。
1、Collections接口有两个直接扩展的子类:List和Set
List接口里存放的集合元素是有顺序的、可以重复的,该接口常用的实现类主要有ArrayList、Vector(顺序储存,支持元素的快速访问,但是插入、删除速度慢),LinkedList(链式储存,元素插入、删除性能好);
Set接口中不按顺序存放集合元素,不允许重复元素存在,实现的类主要有HasSet、LinkedHashSet、TreeSet;
2、Interator是用于遍历集合元素的接口,相当于指向集合元素的指针。大部分集合类都实现Interator接口,该接口方法
(1)public boolean hasNext():是否还有下一个元素;
(2)public Object next():指针移动到下一个元素,并返回下一个元素对象;
(3)public void remove():删除当前指针指向的元素;
3、Map是另一种集合接口,与Collections接口没有关系,Map集合中存放的是键值对,而不是一个单独的对象,键不能重复,值可以重复。
Collection接口
1、add(Object obj):将对象加入集合中;
2、clear():清除当前集合的所有元素;
3、contains(Object obj):判断当前集合中是否包含obj对象;
4、iterator():得到当前集合的迭代器;
5、remove(Object obj):删除当前集合的obj对象;
6、size():得到当前集合中元素的总数;
7、isEmpty():判断当前集合是否为空;
8、toArray():将当前集合的对象转化为对象数组;
Set接口
实现类:1、HashSet:使用哈希表实现Set集合,允许存放null元素,不保证元素的排列顺序
2、AbstractSet:所有Set的实现类直接或间接继承AbstractSet父类;
3、LinkedHasSet:使用链表实现Set集合,用来给元素排序;
4、TreeSet:使用二叉树实现Set集合,用来对元素进行排序;
构造方法:1、HasSet():构造出空HashSet对象,也可以给传一个指定集合的参数;
import java.util.HashSet;
import java.util.Set;
public class SetDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
Set set=new HashSet();
set.add("1");//这个1和后面的1不一样,所以输出的集合元素中有两个1
set.add("a1");
set.add("s1");
set.add(new Double(12.8));
set.add(new Integer(1));
set.add("s1");
System.out.println("set="+set);
//集合中六个元素,输出五个元素,因为有类型一致的相同元素s1
for(Object s:set) {
System.out.println(" "+s);
//集合的遍历,遍历输出集合中的元素
}
}
}
List接口
成员方法:1、add(int index,Object obj):在集合index的位置插入obj对象;
2、set(int index,Object obj):将index位置的元素用对象obj代替;
3、get(int index):返回index位置的元素;
4、listIterator():返回当前集合中元素的列表迭代器对象;
实现类: ArrayList、Vector、LinkedList;
Map集合
成员方法:1、keySet():返回Map中包含的键的set集合;
2、values():返回Map中包含的值的collection集合;
3、entrySet():返回Map中包含的映射关系(键值对)的set集合;
4、clear():清空整个集合;
5、get(Object obj):根据关键字obj得到对应的值;
6、put(Object key,Object vlaue):将键值对加入到当前的Map中;
7、remove(Object obj):从当前Map中删除key代表的键值对;
实现类:1、HasMap采用哈希表算法实现Map接口,不能保证其元素的存储顺序(即不保证放入与取出的顺序一致),也不允许重复;
HashMap比较常用:
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class MapDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
Map map=new HashMap();//创建Map的集合
map.put("studentid","001");//给Map集合中加上参数
map.put("name", "张三");
Set keySet=map.keySet();//获取键,产生键的集合
Iterator keyIterator=keySet.iterator();//创建一个迭代器,指向集合中的键
while(keyIterator.hasNext()) {
System.out.print(keyIterator.next()+" ");//遍历集合中的键
}
Set entrySet=map.entrySet();//entry的集合
Iterator entryIterator=entrySet.iterator();//创建一个迭代器,指向整个集合
while(entryIterator.hasNext()) {
System.out.print(entryIterator.next()+" ");//遍历集合中的没和对象
}
String name=(String) map.get("name");//这个name本身是Object类型,所以需要转换为String类型传给name
System.out.println(name);
}
}
2、TreeMap采用红黑树算法实现Map接口,key会按照自然顺序或定制排序进行排序,也不允许重复;
3、LinkedHasMap采用链表和哈希表算法实现Map接口,key会保证先后添加的顺序,不允许重复;
集合的遍历
无序集合Set的遍历
1、迭代器遍历
Iterator it=new Iterator();
while(it.hasNext()){//判断该迭代器中是否还有元素需要迭代,返回true和false
System.out.println(it.next());//返回迭代器的下一个元素,指针下移
}
2、for-each遍历
for(数据类型 循环变量:需要遍历的集合对象){
循环体;
}
for(Object ob:list){
System.out.println(ob);
}
有序集合遍历
1、迭代器遍历
List list=new ArrayList();
list.add("first");
list.add("second");
ListIterator it=list.ListIterator();
while(it.hasnext()){//判断该迭代器中是否还有元素需要迭代,返回true和false
System.out.println(it.next());//返回迭代器的下一个元素,指针下移
}
2、for-each遍历【和无序遍历一样】
3、for循环
for(int i=0;i<list.size();i++){
Object obj=list.get(i);
}
Map的遍历是先将键赋值给一个Set集合,遍历Set集合
Comparable和Comparator接口
Comparable
Comparable是定义对象本身的内在默认的排序标准;
Comparable接口下有一个compareTo的抽象方法;
public interface Comparable<T>{
public int compareTo(T t);//返回值为一个整数
}//T是指泛型
//返回值大于零,表示当前对象大于t这个对象;等于,则相等;小于,则小于
Comparator
Comparator是在对象外部定义其他排序标准;
Comparator接口下有一个compare的抽象方法;
public inerface Comparator<T>{
int compare(T t1,T t2);
//其他方法
}