Java学习笔记（3.24）

不是铝铜

已于 2024-03-24 22:04:52 修改

阅读量1.1k

点赞数 34

文章标签： java 学习笔记

于 2024-03-24 22:02:14 首次发布

本文链接：https://blog.csdn.net/2301_79690135/article/details/136853924

版权

一、泛型

功能：提供了编译时类型安全的检测机制，该机制允许在编译时检测到非法的类型。

本质：参数化类型，也就是说所操作的数据类型被指定为一个参数。

定义：将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型。

用处：可以用在类、方法、接口中，分别称为泛型类、泛型方法、泛型接口。

格式：

<类型>：指定一种类型的格式。这里的类型可以看成时形参。

<类型1，类型2...>：指多种类型的格式，多种类型之间用逗号隔开。这里的类型可以看成形参。

*具体调用的时候给定的类型可以看成实参，并且实参的类型只能是引用数据类型。

好处：

把运行期间的问题提前到编译期间。

避免了强制类型。

1、泛型类

定义格式：

修饰符 class 类名 <类型>{}

package myGeneric;

public class Generic <T>{
	private  T t;
	public T getT() {
		return t;
	}
	public void setT(T t) {
		this.t = t;
	}
	
}

2、泛型方法

修饰符 <类型> 返回值类型方法名（类型变量名）{ }

public <V> void show(V v) {
		System.out.println(v);
	}

3、泛型接口

修饰符 interface 接口名 <类型>{ }

public interface Generic<T> {
		void show （T  t）;
	}

4、类型通配符

为了表示各种泛型List的父类，可以使用类型通配符。

类型通配符：<?>

List<?>:表示元素类型未知的List，他的元素可以匹配任何的类型。

这种带通配符的List仅表示它是各种泛型List的父类，并不能把元素添加到其中

-------------------------------------------------------------------------------------------------------------

如果说我们不希望List<？>是任何泛型List的父类，只希望它代表某一类泛型List的父类，可以使用类型通配符的上限

类型通配符上限：<？extends类型>

List <？ extends Number>：它表示的类型是Number或者其子类型

-------------------------------------------------------------------------------------------------------------------

我们也可以指定类型通配符的下限

类型通配符下限：<？super类型>

List<? super Number>: 它表示的类型是Number或Number的父类型。

5、可变参数

又称参数个数可变，用作方法的形参出现，这个方法参数个数就是可变的了。

格式：

修饰符返回值类型方法名（数据类型...变量名）{ }

package myArgs;

public class ArgsDemo {
	public static void main(String[] args) {
		
		 System.out.println(sum(100,20));
		 
	}


public static int sum(int...a) {
	//a相当于一个数组
	//可变参数要放在最后
	int sum=0;
	for(int i:a) {
		sum+=i;
	}
	return sum;
}
}

可变参数的使用：

Arrays工具类中有一个静态方法：

• publicstatic <T> List <T> asList（T.. a）：返回由指定数组支持的固定大小的列表。

•返回的集合不能做增删操作，可以做修改操作。

List接口中有一个静态方法：

• publicstatic <E> List<E> of（E.. elements）：返回包含任意数量元素的不可变列表。

• 返回的集合不能做增删改操作

Set接口中有一个静态方法：

• publicstatic <E> Set<E> of（E.. elements）：返回一个包含任意数量元素的不可变集合。

• 在给元素的时候，不能給重复的元素。

package myArgs004;

import java.util.Arrays;
import java.util.List;
import java.util.Set;

public class ArgsDemo {

	public static void main(String[] args) {
		List<String>list1=Arrays.asList("hello","world","java");
		//list1.add("javaee");//UnsupportedOperationException
		//list1.remove("java");//UnsupportedOperationException: remove
		//不能添加或删除，因为该操作会让list的大小发生改变
		list1.set(0,"haha");
		System.out.println(list1);
		System.out.println("-----------------------");
		
		
		List <String> list2=List.of("hello","world","java","world");
		//List可以重复
		//list2.add("javaee");//UnsupportedOperationException
		//list2.remove("java");//UnsupportedOperationException: remove
		//list1.set(0,"haha");UnsupportedOperationException
		System.out.println(list2);
		
		
		Set<String>set=Set.of("hello","world","java");
		//set.add("world");UnsupportedOperationException
		//set.remove("world");UnsupportedOperationException
		System.out.println(set);
	}

}

二、Map

Map集合概述
• Interface Map<KV> K：键的类型；V：值的类型。

1、创建Map集合的对象：

•多态的方式。

•具体的实现类HashMap

package myMap001;

import java.util.HashMap;
import java.util.Map;

public class MapDemo {

	public static void main(String[] args) {
		Map<String,String> map=new HashMap<String,String>();
		map.put("a1","a2");
		map.put("b1","b2");
		map.put("c1","c2");
		System.out.println(map.remove("a1"));
		//根据键删除键值对应元素
		
		System.out.println(map.remove("d1"));
		//map中没有对应的键，返回一个null
		
		map.clear();
		//清空map
		System.out.println(map);
		
		map.put("a1","a2");
		map.put("b1","b2");
		map.put("c1","c2");
		System.out.println(map.containsKey("a1"));
		System.out.println(map.containsKey("d1"));
		//containsKey返回boolean类型，map中有该键，返回true，没有该键返回false
		
		System.out.println(map.containsValue("a2"));
		System.out.println(map.containsValue("a1"));
		//containsValue返回boolean类型，map中存在该键值返回true，没有该键值返回false
		
		System.out.println(map.isEmpty());
		//判断集合是否为空
		
		System.out.println(map.size());
		//输出map的大小
		System.out.println(map);
		
		
	}

}

2、Map集合的获取功能。

map遍历：

Set<Map.Entry<K,V>>entrySet();

获取所有键值对对象的集合。

用getKey()得到键。

用getValue()得到键值。

package myMap001;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class MapDemo002 {
	public static void main(String[] args) {
		Map<String,String>map=new HashMap<String,String>();
		map.put("a1","a2");
		map.put("b1","b2");
		map.put("c1","c2");
		System.out.println(map.get("a1"));
		//根据键得到键值
		System.out.println(map.get("d1"));
		//键不存在的时候返回null
		
		Set<String> keySet=map.keySet();
		for(String i:keySet) {
			System.out.println(i);
		}
		//keySet用于获取所有的键
		
		Collection<String> values=map.values();
		for(String i:values) {
			System.out.println(i);
		}
		//values()用于获取所有值的集合
		
		//map遍历
		//Set<Map.Entry<K,V>>entrySet();
		Set<Map.Entry<String,String>> entrySet=map.entrySet();
		for(Map.Entry<String,String> me:entrySet) {
			String key=me.getKey();
			String value=me.getValue();
			System.out.println(key+","+value);
		}
	}
}

三、Collections

概述：是针对集合操作的工具类。

常用方法：

• publicstatic <T extends Comparable<？super T>> void sort（List <T> list）：将指定的列表按升序排序。

• publicstatic void reverse（List <？> list）：反转指定列表中元素的顺序

• publicstatic void shuffle（List <？> list）：使用默认的随机源随机排列指定的列表

package myCollections001;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class CollectionsDemo {
	public static void main(String[] args) {
		List<Integer> list=new ArrayList<Integer>();
		list.add(12);
		list.add(11);
		list.add(13);
		list.add(10);
		System.out.println(list);
		
		Collections.sort(list);
		//将指定列表按升序排列
		System.out.println(list);
	
		Collections.reverse(list);
		//将指定列表中的元素顺序反转
		System.out.println(list);
		
		Collections.shuffle(list);
		//将列表随机排序
		System.out.println(list);
	}
}

四、IO流

1、File

概述：它是文件和目录路径名的抽象表示。

•文件和目录是可以通过File封装成对象的。

•对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。它可以是存在的，也可以是不存在的。可以通过具体操作把这个路径的内容转换为具体存在的。

1、File构造方法

package myFile001;

import java.io.File;

public class FileDemo {

	public static void main(String[] args) {
		File f1=new File("D:\\javaUsed\\java.txt");
		System.out.println(f1);
		
		File f2=new File("D:\\javaUsed","java.txt");
		System.out.println(f2);
		
		File f3=new File("D:\\javaUsed");
		File f4=new File(f3,"java.txt");
		System.out.println(f4);
	}

}

2、File类创建功能

package myFile001;
import java.io.File;
import java.io.IOException;
public class FileDemo002 {
	public static void main(String[] args) throws IOException {
		File f1=new File("D:\\javaUsed\\java.txt");
		System.out.println(f1.createNewFile());
		//文件不存在，就会创建文件并返回true；文件存在，返回false
		
		File f2=new File("D:\\javaUsed\\javaSE");
		//目录不存在，就会创建文件并返回true；目录存在，返回false
		System.out.println(f2.mkdir());
		
		File f3=new File("D:\\javaUsed\\javaWEB\\HTML");
		//System.out.println(f3.mkdir());
		//该方法不能创建多级文件
		System.out.println(f3.mkdirs());

	}
	

}

3、File的删除功能

package myFile001;

import java.io.File;
import java.io.IOException;

public class FileDemo003 {
	public static void main(String[] args) throws IOException {
		File f1=new File("java.txt");
		System.out.println(f1.createNewFile());
		//在当前目录下创建java.txt文件
		
		System.out.println(f1.delete());
		//在当前目录下删除java.txt文件
		
		File f2=new File("myIO\\myFile002");
		System.out.println(f2.mkdir());
		//在当前目录下创建myFile002目录
		
		System.out.println(f2.delete());
		//在当前目录下删除myFile002目录
		//不能越级创建，也不能越级删除
	}

}

4、File类判断和获取的功能

package myFile001;

import java.io.File;
import java.io.IOException;

public class FileDemo004 {
public static void main(String[] args) throws IOException {
	File f1=new File("java.txt");
	f1.createNewFile();
	System.out.println(f1.isDirectory());
	//测试此抽象路径名表示的File是否为目录
	System.out.println(f1.isFile());
	//测试此抽象路径名表示的File是否为文件
	System.out.println(f1.exists());
	//测试此抽象路径名表示的File是否为存在
	
	System.out.println(f1.getAbsolutePath());
	//返回此抽象路径名的绝对路径名
	System.out.println(f1.getPath());
	//返回此抽象路径名的路径名字符串
	System.out.println(f1.getName());
	//返回此抽象路径名表示的文件名或目录名名称
	System.out.println("-----------------");
	
	File f2=new File("C:\\Users\\yushimin\\eclipse-workspace\\myIO002");
	String []arr=f2.list();
	//返回此抽象路径名表示的目录中的文件和目录的名称字符数组
	for(String str:arr) {
		System.out.println(str);
	}
	System.out.println("----------------");
	
	File[]fileArr=f2.listFiles();
	for(File f:fileArr) {
		System.out.println(f);
		//返回此抽象路径名表示的目录中的文件和目录的File对象数组
		System.out.println(f.getName());
	}
}
}