Java——常用类库

最新推荐文章于 2024-07-19 17:37:28 发布

会不会学不会

最新推荐文章于 2024-07-19 17:37:28 发布

阅读量972

点赞数 25

文章标签： java 开发语言

本文链接：https://blog.csdn.net/2302_79062950/article/details/139790344

版权

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);
    //其他方法
}

会不会学不会

关注

25
点赞
踩
15

收藏

觉得还不错? 一键收藏
0
评论
Java——常用类库

Collections接口是集合层次框架的跟接口，是存储单一对象的集合(即每个位置保存的是单一的对象)。1、Collections接口有两个直接扩展的子类：List和SetList接口里存放的集合元素是有顺序的、可以重复的，该接口常用的实现类主要有ArrayList、Vector(顺序储存，支持元素的快速访问,但是插入、删除速度慢)，LinkedList(链式储存，元素插入、删除性能好)；
复制链接

扫一扫