关于java基础学习集合的相关知识点

最新推荐文章于 2023-10-30 08:00:00 发布

WJZ0805UP

最新推荐文章于 2023-10-30 08:00:00 发布

阅读量129

点赞数

分类专栏： java 文章标签： java 集合论

本文链接：https://blog.csdn.net/WJZ0805UP/article/details/108059879

版权

java 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

一集合

1 集合概述

集合可以存储不同类型的元素，只能存储引用类型数据，饥饿和的长度是可变的

集合的结构体系

Collection：

在list集合中允许由重复的元素，而在set集合中不允许有重读的元素

在list集合中是有序的，在set集合中是无序的

JDK不为其提供此接口的任何子类，实现其：它提供更具体的子接口（set和list）实现

Collection的基本功能：

添加元素：loolean add（Object e）：添加任意的引用类型元素

删除元素：loolean remove（Object o）：删除指定的元素

void clear（）：清空集合中的所有元素

判断功能：

boolean contains（Object o）：判断是否包含指定的元素，包含返回true，否则返回false

获取元素：

int size()：获取集合中的元素数

Object[ ] toArray（）：将集合进行遍历---->将集合转换成数组遍历

Interger< Object>integer（）：获取Collection的集合的迭代器（集合遍历的专有方法）

简单举例

public class CollectionDemo {
	
	public static void main(String[] args) {
		Collection c = new ArrayList() ;
		System.out.println(c);//集合重写了Object类中toString()方法
		c.add("hello") ;
		c.add("world") ;
		c.add("javaee") ;
		c.add("hello")   
		System.out.println("------------------------------");
        
		//删除指定的元素
		System.out.println("remove():"+c.remove("world"));
		//void clear() :清空集合中的所有元素 (暴力删除)
		//c.clear() ;
		System.out.println("conatins():"+c.contains("javaee"));
		System.out.println("conatins():"+c.contains("python"));
		System.out.println("isEmpty():"+c.isEmpty());
      
		System.out.println("-----------------------");
        
		//集合中获取长度:size()
		System.out.println("size():"+c.size());
		System.out.println(c);
	}
}

2集合的遍历

使用Collection集合存储字符串并遍历

一般情况：集合的遍历使用的是迭代器遍历（集合专有的遍历方式）

toarray（）方法是将集合转换成数组

public class CollectionDemo{
public static void main(String [] args){
//创建集合对象
    Collection c = new ArrayList();
    //添加字符串元素
    c.add("hello");
    c.add("world");
    c.add("java");
    
    //遍历
    Object [] obj = c.toArray();
    for(int x = 0;x <obj.length;x++){
        String s = (String) obj[x];//向下转型
        System.out.println(s+" "+s.length);
    	}    
	}
}

3 关于集合的专有遍历

专有遍历方式：Iteratoriterator()

返回值是迭代器-----接口

Object next():获取下一个元素

boolean hasNext():如果存在一个元素，使用next，获取下一个元素

注意事项：自定义类或者接口的时，不能使用JDK本身存在的类和接口名一样

举例说明：

//需求：给Collection 中添加元素，使用迭代器遍历，使用Collection集合存储自定义对象，使用迭代器遍历
public class IteratorDemo {
	
	public static void main(String[] args) {
        //创建集合对象
        Collection c = new ArrayList();
        //添加元素
        c.add();
        c.add();
        c.add();
        //获取迭代器对象
        Itrator it = c.iterator();
        //使用while循环
        while (it.hasNext()){
            String s = (String)(it.next());
            System.out.printin(s+"  "+s.length());        
        }

4 迭代器的使用

使用迭代器时：

1，集合获取迭代器的时候，集合里面存储的元素类型是什么类型，转换时会出现转换类异常（没有使用泛型）

2，next（）不能多次使用，结果不匹配。

Object obj = 迭代器对象.next（）；

简单实用：

//需求：使用Collection 存储自定义对象，使用迭代器遍历集合
public class IteratorDmo{
public static void main(String [] args){
   //创建集合对象
    Collection c = new ArrayList();
    //创建学生对象
    Student s1 = new Student("姓名",年龄);
    Student s2 = new Student("姓名",年龄);
    Student s3 = new Student("姓名",年龄);
    Student s4 = new Student("姓名",年龄);
    
    //添加元素
      c.add(s1);
      c.add(s2);
      c.add(s3);
      c.add(s4);
    //遍历推荐while循环
    //这里用for循环试一试
    for(Iteratr it = c.iterator();it.hasNext();){
        Student s = (Student)(it.next());
        System.out.println(s.getName()+"  "+s.getAge());
    	}
	}
}

5 JDK5 的新特性之增强for循环

增强for，静态导入（导入的方法级别，该方法是静态）可变参数，自动拆装箱

增强for的目的是为了替代迭代器，简化书写方式

引用场景：主要是在集合中使用，数组也可以使用

格式：

for（数据类型（引用类型）对象名：集合对象名称）{

输出变量名；

}

就简单举例：

public class ForEachDemo {
	
	public static void main(String[] args) {
		
		int[] arr = {11,22,33,44,55} ;
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		
		}
		System.out.println("----------------------");
		/*
		 * 	for(数据类型 变量名: 集合对象名称){
	 			输出变量名;
	 		}
		 * */
		for(int i : arr) {
			System.out.println(i);
		}
		
		//创建一个List集合对象:添加字符串数据
		List<String> list = new ArrayList<String>() ;
		
		//给集合中添加元素
		list.add("hello") ;
		list.add("world") ;
		list.add("java") ;
		
		Iterator<String> it = list.iterator() ;
		while(it.hasNext()) {
			String s = it.next() ;
			System.out.println(s);
		}
		System.out.println("---------------------");
		/*
		 * 
		 * 	for(数据类型 变量名: 集合对象名称){
	 			输出变量名;
	 		}
		 * */
		for (String s : list) { //就是迭代器,只是为了简化书写方式
			//如果这个集合有"world"元素,添加一个Javaee这个元素
//			if("world".equals(s)) {
//				list.add("javaee") ;
//			}
			System.out.println(s);
		}
		System.out.println(list);
	}
}

6 list集合

list 集合是Collection集合的子接口

基本功能以及高级功能都可以继承

特点：

1有序的，存储和去除一致。

2该集合中方可以存在重读的元素。

6.1list集合特有的功能

特有功能：添加元素void add（int index，object element）：在指定位置添加元素（在index位置前面插入）

删除功能：object remove（int index）：删除指定位置的元素，返回该元素

获取功能：object get（int index）：根据索引值获取该元素

修改元素：object set（int index ， object element）：在指定位置用新元素替代旧元素

6.2List集合特有的遍历方式：列表迭代器方法

格式：Listiterator ListIterator();

ListIterator接口 的功能:

正向遍历

boolean hasNext() :判断是否存在下一个元素

Object next() ;获取下一个元素

逆向遍历(单独使用无意义,必须先正向遍历才能使用逆向遍历)

boolean hasPrevious():判断是否存在前一个元素

Object previous():获取前一个元素

列表迭代器中有一个add(Object e):可以使用迭代器去添加元素

List集合的简单利用

public class ListIteratorDemo {
	
public static void main(String[] args) {
	//创建List集合对象
	List list = new ArrayList() ;
	
	//添加元素
	list.add("hello") ;
	list.add("world") ;
	list.add("Java") ;
	//正向遍历
	//获取列表迭代器
	ListIterator lit = list.listIterator() ;
	while(lit.hasNext()) {
		String s = (String) (lit.next()) ;
		System.out.println(s+"---"+s.length());
	}
	System.out.println("-------------------------");
	//逆向遍历
	while(lit.hasPrevious()) {//判断是否有上一个元素
		String s = (String)(lit.previous()) ;
		System.out.println(s+"---"+s.length());
		} 
	}
}

7.程序异常

什么是异常?

在程序的执行过程中,程序出现了一些问题(Bug).

异常的体系结构：

Throwable： Java 语言中所有错误或异常的父类

两个字类：

Error：严重问题(一些其他原因导致的) :需要借助于第三方技术解决

内存溢出（Out Of Memeory）

Exception：不是很严重问题（程序出现代码不严谨或者一些编译问题）

运行时期异常：RuntimeException

举例:ClassCastException/NullPointerException/ArrayIndexOutOfBoundsException

运行时期出现的原因：开发者编码的时候，代码逻辑不严谨!

编译时器异常：只要不是RuntimeException的子类都属于编译时期异常

ParseException（属于编译时期异常）

编译时期异常：jvm在检查语法的时候，针对某些特定的方法针对方法进行判断

如果不解决编译时期异常，程序执行不了的！

异常使用的注意事项:

1)子类继承父类的时候,如果父类的该方法本身就存在异常,那么子类重写父类该方法的时候

必须是该异常或者是异常的子类 (简单记:父亲坏了,儿子不能比父亲还坏)

2)子类继承父类,父类的成员方法如果没有当前异常,子类不能抛出throws,只能try…catch

7.1异常处理

异常的处理方案有两种：

一般开发中常用:捕获异常 try…catch…finally :标准格式

throws/throw：抛出异常

方式1：捕获异常

try…catch…finally :标准格式

变形格式：

1)try…catch…

2)try…catch…catch…3)try…finally… (多线程中见到)

try{

可能出现问题的代码 ;

}catch(异常类名变量名){

处理异常 ;

}

7.2任何处理多个异常

如何处理多个异常

1)一个一个处理

每一个代码都try…catch…

try…catch…

2)变形格式(推荐)

try…catch…catch…catch…

注意事项:

针对多个异常处理的时候，只能大的异常类名放在最后面进行处理,不能放在最前面

JDK7以后：有一种的新的处理方式：（源码里面会看到，看懂格式即可）

try{

可能出现的代码;

}catch(异常类名1 | 异常类名2 | 异常类名3 变量名){

处理异常；

7.3编译时期和运行时期异常

编译时器异常和运行时期的区别？

编译时期异常：开发者必须要处理，否则编译不通过，程序运行不了！

调用者必须针对编译时期的异常进行处理(在方法体中使用的捕获异常,调用者不需要处理

如果是将异常抛出在方法声明上,调用者需要处理)

运行时期异常:

一般情况,针对代码可以不需要显示处理,在代码中加入一些逻辑判断

1)要么显示处理

2)要么代码中加入一些判断即可!

捕获异常的格式：

捕获异常的格式

try{

可能出现问题的代码;

}catch(异常类名变量名){

处理异常;

}finally{

在IO流中/JDBC中释放相关的系统资源;

}

finally中的语句一定会执行,除非是在执行finally代码之前,jvm退出了!

WJZ0805UP

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
关于java基础学习集合的相关知识点

一集合1 集合概述集合可以存储不同类型的元素，只能存储引用类型数据，饥饿和的长度是可变的集合的结构体系Collection：在list集合中允许由重复的元素，而在set集合中不允许有重读的元素在list集合中是有序的，在set集合中是无序的JDK不为其提供此接口的任何子类，实现其：它提供更具体的子接口（set和list）实现Collection的基本功能：添加元素：loolean add（Object e）：添加任意的引用类型元素删除元素：loolean remove（Object
复制链接

扫一扫