JavaSE基础知识之常用类和集合

最新推荐文章于 2022-06-21 16:05:04 发布

不知死活的猿

最新推荐文章于 2022-06-21 16:05:04 发布

阅读量221

点赞数

分类专栏： java中高级文章标签： 1024程序员节 java

本文链接：https://blog.csdn.net/aaa33_3/article/details/109254065

版权

java中高级专栏收录该内容

14 篇文章 1 订阅

订阅专栏

常用类

Object类

protected Object clone() throws CloneNotSupportedException

克隆方法:创建并返回此对象的一个副本
Object 类的 clone 方法执行特定的复制操作。首先，如果此对象的类不能实现接口 Cloneable，则会抛出 CloneNotSupportedException。
protected void finalize()throws Throwable(跟垃圾回收器有关系)
垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。

Scanner类

文本扫描器:Scanner (java.util.Scanner)

之前的使用:
1)导包
2)创建键盘录入对象:
```
Scanner sc = new Scanner(System.in) ;
```
构造方法:
```
 public Scanner(InputStream source)
```
形式参数:
抽象类:java.io.InputStream:字节输入流(用来读取字节数)
如果方法的形式参数是一个抽象类,那么需要传递该抽象类的子类对象
System.in:System:是jdk提供的一类
public static final InputStream in:成员变量 :标准输入流
public static final PrintStream out:标准输出流

Scanner类中提供了一些判断功能:

public boolean hasNextXXX():判断当前是否是执行XXX类型
```
 		int,short,float,double...
```
public XXX nextXXX() :接收指定XXX类型
```
 举例:
```

 		public boolean	haxNextInt() :判断接收的类型是否是int类型

 		public int nextInt()  : 接收指定的int类型的数据

 		public boolean	haxNextLine():判断接收的数据是否是一个String类型

 		public String nextLine() : 接收一个String类型

Scanenr:键盘录入的细节问题

先录入int类型,在录入String类型 (nextLine())
问题:
当前字符串录入数据:值就被漏掉了,原因就是回车符号(本身字符串)
在下一次录入String类型前,再次创建一个Scanner类型对象

String类

常用类之String

String 类代表字符串
字符串是常量；它们的值在创建之后不能更改(常量的地址值)
String类是一个特殊的引用类型
String类型如果作为参数传递,形式参的改变不会影响实际参数
(跟基本类型作为参数的效果一样)
null 和 ""的区别: null:对象为空 " ":空字符序列 “” +任何数据

String类的构造方法

public String() :无参构造方法:创建一个字符串对象
public String(byte[] bytes):使用平台的默认编码集 :将字节数组---->构造出String类型
public String(byte[] bytes, int offset, int length):将字节数组的一部分转换成字符串
参数1:传递的实际字节数组对象
参数2:从哪个位置开始
参数3:指定长度
public String(char[] value):将字符数组—构造成一个字符串对象
public String(char[] value,int offset,int count) :将字符数组一部分转换成字符串
参数1:传递的实际字符数组对象
参数2:从哪个位置开始
参数3:指定长度
public String(String original):将一个字符串值存储进来,创建一个字符串对象

String类型的判断功能

public boolean equals(Object anObject):比较两个字符串内容是否相同
public boolean equalsIgnoreCase(String anotherString):不区分大小写比较
public boolean startsWith(String prefix):判断是否以指定的子串开头
public boolean endsWith(String suffix):判断是否以指定的子串结尾
public boolean isEmpty():判断字符串是否为空

tring类的获取功能:

int length():获取字符串长度
public char charAt(int index):获取指定索引处的字符
public String concat(String str):字符串拼接功能:使用当前字符串和指定str字符串进行拼接
public int indexOf(int ch):获取指定字符在此字符串中第一次出现索引值
public int indexOf(String str):获取指定字符串在此字符串中第一次出现索引值

String类的分割功能

public String[] split(String regex):通过指定的字符串进行分割,返回值字符串数组

String类转换功能:

public char[] toCharArray():将字符串转换成字符数组
public byte[] getBytes() :将字符串----变成字节数组 (过程:编码)
public static String valueOf(XXX xx):可以将任何类型的数据转换成String
public String toUpperCase():将此字符串转换成大写
public String toLowerCase():将此字符串转换成小写

String类的截取功能

public String substring(int beginIndex):从指定位置开始截取,默认截取到末尾
public String substring(int beginIndex,int endIndex)
从指定位置开始截取,到指定位置结束,但是包含beginIndex,不包含endIndex索引(包前不包后)

替换功能

public String replace(char oldChar,char newChar):将以前的字符用心的字符替换掉
public String replace(String oldStr,char newStr):将以前的字符用心的字符替换掉
去除两端空格 public String trim()
按照字段顺序比较! :如何比较的
public int compareTo(String anotherString)

StringBuffer类

StringBuffer:线程安全的可变字符序列 ,提供字符串缓冲区

多线程有关系!
进程:—>打开任务管理器,一些客户后台!
线程—相当于开启进程后的某一个任务! 360软件
线程安全 ---->同步的----->执行效率低 !
举例:银行的网站
医院网站…
线程不安全---->不同步的---->执行效率高!
举例:
论坛网站,部分游戏网站…
两个获取功能
int length():获取长度(缓冲区中字符数)
public int capacity():获取缓冲区的容量大小
StringBuffer的构造方法:
1)public StringBuffer():空参构造,初始容量为 16 个字符。(默认的容量足够,不需要指定容量大小)
2)public StringBuffer(String str):构造一个缓冲区,指定字符串内容到缓冲区中,容量大小等于16个+当前字符串的实际长度
3)public StringBuffer(int capacity):指定容量大小,构造一个缓冲区
注意事项:
不能将String类型的值赋值给一个StringBuffer类型
StringBuffer sb = “hello” ; //错误的
String s = new String(“hello”) ;
StringBuffer sb2 = s ; //错误的

StringBuffer的添加功能:

public StringBuffer append(任何类型数据…):将任何类型的数据追加到缓冲区中(追加末尾)
public StringBuffer insert(int offset,String str/任何类型数据):将某个元素插入到指定位置

StringBuffer的删除功能

public StringBuffer deleteCharAt(int index):删除指定位置处的字符,返回缓冲区本身
public StringBuffer delete(int start,int end):删除从指定位置到指定位置结束(包前不包后,end-1位置)

关于:反转功能

键盘录入一个数据,将字符串进行反转—(内容还是字符串内容)
public StringBuffer reverse():将缓冲区中的字符进行反转!

StringBuffer的其他功能

StringBuffer的截取功能
public String substring(int start):从指定位置开始截取,默认截取到末尾
public String substring(int start, int end):从指定位置开始截取,截取到指定位置结束!

StringBuffer的替换功能

public StringBuffer replace(int start,int end, String str)
从指定位置开始到指定位置结束(end-1处)使用str子串进行替换

String <----> StringBuffer类型的相互转换

//String---->StringBuffer
	String s = "world" ;
	//StringBuffer sb = s; //type Mismatch:类型不匹配
	//方式1:通过StringBuffer构造方法:StringBuffer(String str)
	StringBuffer sb = new StringBuffer(s) ;
	System.out.println(sb);
	System.out.println("-------------------------------");
	
	//方式2:StringBuffer()无参构造+append(String str):追加
	StringBuffer sb2 = new StringBuffer() ;
	sb2.append(s) ;
	System.out.println(sb2);	
	System.out.println("-------------------------------");
	
//StringBuffer----->String
	StringBuffer buffer = new StringBuffer("hello") ;
	//方式1
	//public String(StringBuffer buffer):String类型的构造方法
	String str = new String(buffer) ;
	System.out.println(str);
	
	System.out.println("-------------------------------");
	//StringBuffer--->public String toString() 
	String str2 = buffer.toString() ;
	System.out.println(str2);

将数组拼接字符串 "[元素1, 元素2, 元素3, ....]"
//方式1定义一个功能: 将数组拼接成String
	public static String arrayToString(int[] arr) {
		//定义一个结果变量
		String result = "" ;
		//拼接左中括号
		result += "[" ;
		//遍历数组
		for (int i = 0; i < arr.length; i++) {
			if(i==arr.length-1) {
				result += arr[i] ;
				result += "]" ;
			}else {
				result += arr[i] ;
				result += ", " ;
			}
		}
		return result;
	}
	//方式2:使用StringBuffer的append追加
	public static String arrayToString2(int[] arr) {
		//创建一个StringBuffer对象
		StringBuffer sb = new StringBuffer() ;
		sb.append("[") ;
		//遍历数组
		for (int i = 0; i < arr.length; i++) {
			if(i==arr.length-1) {
				sb.append(arr[i]).append("]") ;
			}else {
				sb.append(arr[i]).append(", ") ;
			}
		}
		return sb.toString() ;
	}

字符串内容反转
//方式1
	public static String reverse(String s) {
		//定义一个结果变量
		String result = "" ;
		//将s变量---->变成字符串数组
		char[] chs = s.toCharArray() ;
		for(int x = chs.length-1; x >=0 ; x --) {
			//拼接每一个元素
			result += chs[x] ;
		}
		return result ;
	}
	//方式2:利用StringBuffer的reverse()方法
	public static String reverse2(String s) {
		//一步走
		return new StringBuffer(s).reverse().toString();
	}

StringBuffer,StringBuilder和数组的区别

前两个都是字符串缓冲区,都支持可变的字符序列,有相同的api
前者:它是一个线程安的,-----同步的----->执行效率低(线程安全的类)
后者:它是一个线程不安全的—不同步的---->执行效率高单线程程序---->考虑效率问题---->后者会将前者替换掉!
多线程程序—>最重要的安全问题---->StringBuffer了他们和数组: 都容器,都可以存储数据的!

字符串缓冲区:存储数据最终以"字符序列"存储的(StringBuffer/StringBuilder)

 				长度可变,可以不断追加:append(xxx)
 				字符串遍历:length()+charAt(int index) 			数组:只能存储同一种类的元素
 				长度是固定的,(也是数组的弊端)
 				数组的遍历:length属性:获取数组长度

StringBuffer和String类型作为形式参数有什么区别:

两个都是引用类型
String类作为形式参数,它的效果基本数据类型一样(String是最特殊的引用类型)
String是一个常量,一旦被赋值,其值不能被改变
StringBuffer/StringBuilder,他们作为形式参数,
形式参数的改变会直接影响实际参数(和其他引用类型效果一样)

Integer类

Integer类:包含了int类型的值

public static String toBinaryString(int i):将整数值以"二进制"文本形式体现…
public static String toOctalString(int i)
public static String toHexString(int i)
成员变量(字段)
public static final int MIN_VALUE:最小值
public static final int MAX_VALUE:最大值

Integer类的构造方法

Integer(int value) :将int类型包装了Integer类型
Integer(String s) :将字符串内容包装Integer类型
注意事项:
String是一个数字字符串,否则出现异常!
Jdk5提供一些特性:自动拆装箱功能,后面: 静态导入(导入到方法的级别:前提方式静态的),可变参数(public static 返回值类型方法名(int …))

增强for循环(集合),泛型:类名/接口名<引用类型>
举例:
基本类型----引用类型: 自动装箱 int---->Integer
引用类型—基本数据类型 : 自动拆箱 :Integer --int
String----->int :Inerget.parseInt(String str)
String----->long :Long.parseLong(String str)
String----->double:Double.parseDouble(String str)
int------>String: Integer.toString(int i)

Character类

Character:char类型的包装类类型,包含一个char类型的值

构造方法
public Character(char value)
判断功能:
public static boolean isDigit(char ch):判断当前字符是否是数字字符
public static boolean isLowerCase(char ch):判断当前字符是否是小写字母字符
public static boolean isUpperCase(char ch):判断当前字符是否是大写字母字符

java.util.Calendar类:日历类

Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法，
并为操作日历字段（例如获得下星期的日期）提供了一些方法
Calendar不能直接实例化!
某一个类如果不能直接实例化:
首先里面会存在一些静态功能,静态功能的返回值就是该类本身!
public static Calendar getInstance()
public int get(int field):获取的日历字段的值!
参数:传递日历字段

Calendar的成员方法:

给日历字段添加或者减去时间偏移量
public abstract void add(int field,int amount)
日历对象.add(Calendar.DATE,-5):当前日历时间的5天前
设置当前年月日,日历时间
public final void set(int year,int month, int date)

Date类

java.util.Date类

特定的瞬间，精确到毫秒。
构造方法:
```
 public Date() 无参构造
```
成员方法:

 public long getTime() :返回1970 年 1 月 1 日所表示的时间毫秒

java.util.Date 应用场景 String:文本格式和Date格式的相互转换
关于

String文本格式和Date日期格式相互转换
Date---------------->String 日期文本格式 "格式化"操作
java.text.DateFormat:可以将日期和文本相互转换
DateFormat继承自Format类:都是抽象类,不能直接实例化!,提供更具体的子类

 java.text.SimpleDateFormat extends DateFormat

它允许进行格式化（日期 -> 文本）、解析（文本 -> 日期）
SimpleDateFormat的构造方法

 public SimpleDateFormat(String pattern):

创建一个SimpleDateFormat对象

 参数:指定一个模式 要遵循一定的规则(jdk对它规定了)

        y年	------2020		"yyyy"
     	M年中月份----10/03   "MM"
 		d月中的天数----05/21  'dd'
		h:表示上午/下午的小时数  hh
 		H:一天中的小时数		  HH
 		m:分钟数				  mm
 		s:秒数				  ss

模式

“yyyy-MM-dd HH:mm:ss”
“yyyy年MM月dd日 HH时mm分ss秒”
Date---->String
格式化的步骤:
1)存在Date对象
2)创建SimpleDateFormat(String pattern)
3)public final String format(Date date):格式化方法

解析
String----->Date

步骤:

   1)存在String  "日期文本"   "2020-10-21"
    2)创建SimpleDateFormat(String pattern)
    3)public Date parse(String source)  throws ParseException

解析:
SimpleDateFormat中的参数模式:必须和String 日期文本格式一致,否则出现解析异常(ParseException)
例如:定义一个工具类

 /**
	 * 这个方法是将Date日期格式转换成日期文本格式
	 * @param date  当前日期对象
	 * @param pattern 指定模式 yyyy-MM-dd(年月日)
	 * @return 返回的结果表示是当前日期文本
	 */
	public static String date2String(Date date,String pattern) {
		//分步走
		//创建SipleDateFormat对象
		/*
		SimpleDateFormat sdf = new SimpleDateFormat(pattern) ;
		//格式化
		String dateStr = sdf.format(date) ;
		return dateStr ;
		*/
		return new SimpleDateFormat(pattern).format(date) ;
	}
	
	/**
	 * 这个方法是将日期文本转换成日期格式
	 * @param source  已知存在的日期文本
	 * @param pattern  指定模式 yyyy-MM-dd(年月日)
	 * @return 返回的结果是日期格式Date
	 * @throws ParseException 
	 */
	public static Date string2Date(String source,String pattern) 
			throws ParseException {
		//创建SimpleDateFormat对象
		/*
		SimpleDateFormat sdf = new SimpleDateFormat(pattern) ;
		Date date = sdf.parse(source) ;
		return date ;
		*/
		return new SimpleDateFormat(pattern).parse(source) ;
	}
测试:
public static void main(String[] args) throws ParseException {
		
		//Date--->String  格式化操作
		Date date = new Date() ;
		String dateStr = DateUtils.date2String(date, "yyyy"
				+ "-MM-dd") ;
		System.out.println(dateStr);
		System.out.println("---------------------------------");
		String dateStr2 = DateUtils.date2String(date, "yyyy-MM-dd HH:mm:ss") ;
		System.out.println(dateStr2);//2020-10-21 14:28:32
		
		System.out.println("---------------------------------");
		//String---->Date:解析操作
		String s = "2008-5-12 14:28:00" ;
		Date d = DateUtils.string2Date(s, "yyyy-MM-dd HH:mm:ss"); //模式必须和String文本格式一致
		System.out.println(d);//Mon May 12 14:28:00 CST 2008
	}

BigDecimal类

java.math.BigDecimal

描述:对浮点类型的数据进行精确计算的!
构造方法:
public BigDecimal(String val) :字符串"数字字符串"
```
 		"1.0"
```
```
 		"0.01.."
```
成员方法:

 public BigDecimal add(BigDecimal augend) :求和

 public BigDecimal subtract(BigDecimal subtrahend):减法

 public BigDecimal multiply(BigDecimal multiplicand):乘法

 public BigDecimal divide(BigDecimal divisor)

Math类

java.lang.Math:

Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。
public static double abs(double a/…):求某个数据的绝对值
public static double ceil(double a):向上取整
public static double floor(double a):向下取整
public static int min(int a, int b):求两个int数据的最小值
public static int max(int a,int b):求两个int数据的最大值
public static double random():随机数[0.0,1.0) ---------> Java提供随机数生成器:Random类 nextInt(int n)
public static int round(float a):四舍五入…
public static long round(double a)
public static double sqrt(double a):开根(一个正整数的平方根) 4—2
public static double pow(double a,double b):返回结果:a的b次幂
动态导入:
import 包名.类名;
import java.util.Date/Scanner/List/ArrayList…

静态导入的格式:

import static 包名.类名.方法名;
前提这些方法是静态的
使用静态导入的注意事项:

 如果当前类中出现了和导入的静态方法名一样,冲突了,在使用静态导入的这个的方法的时候

就必须带上限定(包名.类名)

  例如:
             System.out.println(java.lang.Math.abs(-100));

Object array

对象数组

能够存储对象的数组

使用数组存储引用数据类型是可以实现的,但是它不满足长度可变的需求,Java提供了 —“集合”,支持长度可变的

集合特点:只能存储引用数据类型!

Random类

java.util.Random:随机数生成器

构造方法

public Random() :(推荐),产生的随机数是变化的
public Random(long seed):每次产生的随机数是固定的!

成员方法:

public int nextInt():获取的是int范围内的随机数
public int nextInt(int n):获取0到n之间的随机数[0,n)

获取随机数两种方式:

Math类的random()方法: 返回值double类型
Random类空参构造+nextInt(int n):获取随机数

System类

System 类包含一些有用的类字段和方法。它不能被实例化。
字段:

public static final InputStream in :标准的"输入流"
public static final PrintStream out :标准的"输出流"
键盘录入:

 	Scanner(InputStream in) ---->Scanner(System.in)

输出语句:

 System.out.println("xxx")----->System.out--->PrintStream ps (字节打印流)

 				ps.println("x") : 字节打印流调用方法名println(String str)

成员方法:

 public static void gc() 运行垃圾回收器(手动开启)

实际开发中,开发者不需要开启
运行垃圾回收器,它会调用Obejct类finalize(),回收没有更多引用的对象

 public static void exit(int status):参数状态为0:表示正常终止jvm

 public static long currentTimeMillis():获取当前系统时间的毫秒值

public static void arraycopy(Object src, int srcPos, Object dest,  int destPos, int length)		

 * 		从原数组中的指定位置开始进行复制指定length长度复制到目标数组中的某个位置
 * 		参数1:指定源数组
 * 		参数2:源数组中的某个位置
 * 		参数3:目标数组对象
 * 		参数4:目标数组对象中的某个位置
 * 		参数5:指定几个元素复制(长度)

集合

Collection集合

Collection中的高级功能:

boolean addAll(Collection c):添加一个集合中的所有元素
boolean removeAll(Collection c):只要集合中有一个元素被包含,将这个元素从c1删除掉,则返回true!
boolean containsAll(Collection c):包含所有元素才算包含,返回true
public boolean retainAll(Collection c) 取交集:boolean的真实含义是什么:
c1.retainlAll(c2):c1集合的元素是否发生变化!A集合对B集合取交集,将交集的元素保存到A集合,boolean表达的是A集合是否发生变化如果A集合没有变化的,返回结果false;如果A集合有变化,则返回true!
集合中Iterator迭代器本质:就是具体的子实现类的内部类间接实现了迭代器!

迭代器的注意事项:

1)Object next()获取当前集合的元素(),不能使用多次,使用一次即可,
获取所有元素信息
2)能使用for循环,不推荐(因为以后集合中元素可能不知道个数,使用while循环)
泛型

格式
 			<数据类型:引用数据类型>

集合为了迎合数组的特点,在创建数组的时候,将类型定义了,来保证集合中的元素类型一致的!
泛型的特点:
将集合的类型在创建的时候创建的时候就明确,保证集合操作的安全性!
好处:
1)避免了强制类型转换
2)将运行时期异常提前到了编译时期
3)解决了黄色警告线问题
4)提高了程序的安全性!
泛型可以应用在哪些地方

泛型在集合中使用居多,可以定义类上,可以放在方法上,也可以放在接口上!
没有加入泛型之前,程序存在安全隐患,出现类型不匹配:ClassCastException:属于运行时期异常!

泛型的高级通配符

<?> 当前Object类型/任意Java类型(自定义/jdk提供...)
<? extends E>:向下限定:E类型以及它的子类
<? super E>:向上限定:E类型以及它的父类

List集合

List集合 extends Collection

有序的集合,可以允许元素重复!
有序性:存储和取出一致
使用List集合存储字符串并遍历
使用List集合存储自定义对象并遍历(自己完成!)
两种方式:
```
 1)Object[] toArray()
```
```
 2)Collection集合的Iterator
```

List集合的特有功能:
添加功能

 void add(int index,Object element):在指定位置处添加一个新的元素

删除功能

Object remove(int index):删除角标对应的元素

获取功能

 	Object get(int index) :获取指定位置处的元素

```
 	int size():获取集合的元素数 
```

     Object set(int index,Object element):在指定位置处使用当前元素element元素替换

ListIterator listIterator():List集合的专有遍历方式 :列表迭代器
ListIterator:列表迭代器

ListIterator listIterator()这个方法底层实现:是通过ArrayList里面的成员内部类
```
 		 ListItr extends Itr :实现的
```

正向遍历

boolean hasNext():判断是否有下一个元素
Object next() :获取下一个元素

逆向遍历

boolean hasPrevious():判断是否有上一个元素
Object previous():获取前一个元素

List集合的遍历方式:

 1)Collection集合的方法 Object[] toArray

 2)Collection集合的迭代器Iterator iterator()

 3)size()+Object get(int index):普通for循环

 4)列表迭代器:ListIteraotr listiterator()

```
 5)增强for循环
```

List三个子实现类的特点:

	ArrayList	
			底层数据结构是可变数组结构: 查询快,增删慢
			
ArrayList底层可变数组: 
					ArrayList(int initialCapacity) :通过初始化容量构造ArrayList集合
					默认容量大小:capacity:10个
					ArrayList()---->通过初试容量大小判断是否构造一个新Object[] 数组对象
					结论:它的扩容机制 ---1.5倍扩容
			线程角度:
					线程不安全的类----不同步的----执行效率高!	
					单线程程序中,通常没有告诉使用什么集合的时候,优先采用的是ArrayList集合!	
		
Vector :底层数据数组结构(对象数组)
				查询快,增删慢
			线程角度:
					线程安全的类 ---->同步的----->执行效率低
					多线程程序中要考虑安全问题,使用Vector
		LinkedList:
				底层数据结构:链接列表实现(链表)
				
线程角度:
				线程不安全-----不同步---->执行效率高
				特有功能:
							可以模拟栈结构的:先进后出!
		线程安全的类
				StringBuffer/Vector

Set集合

Set集合的特点:

元素是不重复的,无序的!(存储和取出不一致,取决于底层HashMap实例)
子实现类
```
 HashSet
```
```
 TreeSet
```

使用HashSet集合存储自定义对象并遍历

Student的姓名和年龄如果相同,认为同一个人;发现问题:HashSet集合没有去重
底层依赖于HashCode和equals()方法
可能出现一种情况:

 	成员信息不同,但是hash码值一样

 	比较每一个成员信息的内容是否相同:name  (String)

使用HashSet:底层hash表结构来保证元素的唯一性!
存储自定义对象,必须重写hashcode()和equals()
TreeSet集合(重点:排序条件!)
```
 	排序
```
底层是一种红黑树结构(TreeMap):“自平衡的二叉树”
Map集合:
如何遍历Map集合
```
 HashMap
```
```
 TreeMap
```

ArrayList类

ArrayList集合实现了List接口!

可以存储重复元素,存储和取出一致(有序的)!
ArrayList:单线程程序中考虑执行效率,优先采用!
应用场景:

 网络聊天室  查看在线好友列表

 		   张三  (客户端 Socket)   ArrayList<Socket>

```
 		   李四
```
```
 		   王五
```

在一些嵌套中使用

 HashMap<String,ArrayList<String>>  :Map集合嵌套ArrayList

 ArrayList<ArrayList<Student>> :ArrayList嵌套ArrayList

Vector集合

Vector集合:

底层数组结构:查询快,增删慢
线程安全的---->同步的---->执行效率低!
public boolean add(Object e):传统添加元素的方法
特有功能:

 public void add(int index, E element):插入元素

 public Enumeration<Object> elements()		--- 相当于:Iterator iterator()

```
 		该接口有两个方法
```

 		boolean hasMoreElements():判断是否有下一个元素-----> 相当于:boolean hasNext()

 		Object nextElement():获取一个元素                          -----> 相当于:next()

 public Object elementAt(int index):通过角标获取指定的元素---->

                                                   相当于:Object get(int index)

 elementAt()+size() :vector的普通for遍历方式

  Enumeration和Iterator功能是重复的

场景:

 IO流:合并流 SequenceInputStream 可以将多个文件内容读出来复制到指定文件中!

```
 			操作的输入流!
```

LinkedList集合

LinkedList集合的特点:

 底层数据结构是链接列表,查询慢,增删快

 线程不安全的---不同的---->执行效率高!

应用场景:

 网站中	记录用户浏览过商品足迹  (Web技术:Cookie/Session)

特有功能
添加

 public void addFirst(Object e):将该元素添加到列表的开头!

 public void addLast(Object e):将该元素添加到列表的末尾!

删除

 public Object removeFirst():删除列表第一个

 public Object removeLast():删除列表最后一个

获取

 public Object getFirst():获取第一个

 public Object getLast() :获取第二个

弹栈和压栈

 public Object pop():此列表所表示的堆栈处弹出一个元素

 public void push(Object e):将元素推入此列表所表示的堆栈

例子:模拟栈的先进后出:
public class MyStack {
	
	//成员变量位置
	private LinkedList<String> link = null ;
	
	//无参构造方法
	public MyStack() {
		link = new LinkedList<String>() ;
	}
	
	//提供一个add方法,添加元素
	public void add(String obj) {
		//间接通过自定义的功能:使用LinkedList的功能
		link.addFirst(obj);
		//link.addFirst("hello") ;----"hello"
		//addFirst("world") --->"world","hello"
		//addFirst("java")---->"java","world","hello"
	}
	
	//在通过获取元素
	public String get() {
		//使用LinkedList里面 public Object removeFirst()
		return  link.removeFirst() ;
	}
	
	//判断功能
	public boolean isEmpty() {
		//利用LinkedList 的判断功能
		return link.isEmpty() ; //isEmpty():集合为空,返回值true
	}
	
}

froeach

JDK5之后提供了特性:

<引用类型>泛型,静态导入,增强for,可变参数,自动拆装箱

增强for的格式:

 for(数据类型 变量名 : 数组对象/集合对象(使用最多)){

```
 	输出变量名即可
```
```
 }
```

作用: 是替代迭代器使用,简化遍历集合的书写格式!

注意事项:

 1)增强for主要用在集合中,数组一般使用的时候普通for

```
 2)前提条件:
```

 	要使用增强for循环的话,必须保证该集合不能为null,否则就会出现空指针

```
 			NullPointerException 
```
```
 解决方案:
```
```
 		针对该对象非空判断即可!
```

不知死活的猿

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
JavaSE基础知识之常用类和集合

常用类Object类protected Object clone() throws CloneNotSupportedException克隆方法:创建并返回此对象的一个副本Object 类的 clone 方法执行特定的复制操作。首先，如果此对象的类不能实现接口 Cloneable，则会抛出 CloneNotSupportedException。protected void finalize()throws Throwable(跟垃圾回收器有关系)垃圾回收器确定不存在对该对象的更多引用时，由对象
复制链接

扫一扫