Java笔记第二弹
List常用集合子类的特点
ArrayList底层数据结构是数组
查询快，增删慢
LinkedList底层数据结构是链表
查询慢，增删快
练习：
//ArrayList实现
import java.util.*;
public class Main {
public static void main(String[] args) {
ArrayList<String> a=new ArrayList<String>();
a.add("hello");
a.add("world");
a.add("java");
Iterator<String> it=a.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
//LinkedList实现
import java.util.*;
public class Main {
public static void main(String[] args) {
LinkedList<String> ll=new LinkedList<String>();
ll.add("hello");
ll.add("world");
ll.add("java");
for(String s:ll){
System.out.println(s);
}
}
}
案例：ArrayList集合存储学生对象用三种方式遍历
import java.util.*;
public class Main {
public static void main(String[] args) {
ArrayList<DateUtils> array=new ArrayList<DateUtils>();
DateUtils s1=new DateUtils("lili",19);
DateUtils s2=new DateUtils("zhangliang",20);
DateUtils s3=new DateUtils("wangwu",18);
array.add(s1);
array.add(s2);
array.add(s3);
//增强for循环
for(DateUtils s:array){
System.out.println(s.getName()+","+s.getAge());
}
//普通for循环
for(int i=0;i<array.size();i++){
System.out.println(i);
}
//迭代器
while(it.hasNext()){
DateUtils s=it.next();
System.out.println(s.getName()+","+s.getAge());
}
}
}
LinkedList集合的特有功能
import java.util.*;
public class Main {
public static void main(String[] args) {
LinkedList<String> ll=new LinkedList<String>();
//在第一位添加指定元素
ll.addFirst("hello");
//在末尾添加指定元素
ll.addLast("world");
//在第一位删除元素
ll.removeFirst();
//删除末尾元素
ll.removeLast();
//返回首位元素
System.out.println(ll.getFirst());
//返回末尾元素
System.out.println(ll.getLast());
Set集合
注意：不包含重复元素，不能使用普通for循环遍历
存储字符串并遍历练习
import java.util.*;
public class Main {
public static void main(String[] args) {
Set<String> ss=new HashSet<String>();
ss.add("hello");
ss.add("world");
ss.add("java");
//不可重复
ss.add("hello");
//加强for循环遍历
for(String s:ss){
System.out.println(s);
}
}
}
哈希值
public int hashCode();//返回哈希值
//同一个对象多次调用返回的哈希值是一样的
//默认情况下，不同对象，即便内容相同，返回的哈希值是不一样的
//在重写了hashCode方法的情况下，可以使得哈希值相同
System.out.println(s.hashCode());//得到某位对象的哈希值
hashSet集合
底层数据结构是哈希表
没有顺序，不保证存入与取出一致
不能用普通for循环遍历
不包含重复元素
存储字符串并遍历练习
import java.util.*;
public class Main {
public static void main(String[] args) {
HashSet<String> hh=new HashSet<String>();
hh.add("hello");
hh.add("world");
hh.add("java");
//增强for循环遍历
for(String s:hh){
System.out.println(s);
}
}
}
HashSet集合保证唯一性源码分析
常见数据结构之哈希表（元素为链表的数组）
相关练习：
//Main.java
import java.util.*;
public class Main {
public static void main(String[] args) {
HashSet<Student> hh=new HashSet<Student>();
Student s1=new Student("lili",19);
Student s2=new Student("zhangliang",20);
Student s3=new Student("wangwu",18);
hh.add(s1);
hh.add(s2);
hh.add(s3);
for(Student s:hh){
System.out.println(s.getName()+","+s.getAge());
}
}
}
//Student.java
public class Student {
private String name;
private int age;
public Student(){}
public Student(String name, int age){
this.name=name;
this.age=age;
}
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age=age;
}
public int getAge(){
return age;
}
LinkedHashList集合
元素的存储顺序和取出顺序是一致的
没有重复元素
相关练习：存储字符串并遍历
import java.util.*;
public class Main {
public static void main(String[] args) {
LinkedHashSet<String> ll=new LinkedHashSet<String>();
ll.add("hello");
ll.add("world");
ll.add("java");
for(String s:ll){
System.out.println(s);
}
}
}
TreeSet集合
元素有序：由具体的构造方法决定相应的顺序
不包含重复元素
不能用普通for循环遍历
相关练习：
import java.util.*;
public class Main {
public static void main(String[] args) {
TreeSet<Integer> tt=new TreeSet<Integer>();
tt.add(10);
tt.add(100);
tt.add(1000);
for(Integer mm:tt){
System.out.println(mm);
}
}
}
自然排序Comparable的应用
//Main.java
import java.util.*;
public class Main {
public static void main(String[] args) {
TreeSet<Student> ss=new TreeSet<Student>();
Student s1=new Student("lili",19);
Student s2=new Student("zhangliang",20);
Student s3=new Student("wangwu",18);
ss.add(s1);
ss.add(s2);
ss.add(s3);
for(Student s:ss){
System.out.println(s.getName()+","+s.getAge());
}
}
}
//Student.java
//按照存储顺序
public class Student implements Comparable<Student>{
private String name;
private int age;
public Student(){}
public Student(String name, int age){
this.name=name;
this.age=age;
}
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age=age;
}
public int getAge(){
return age;
}
@Override
public int compareTo(Student o) {
return 1;
}
}
//反向存储顺序
public class Student implements Comparable<Student>{
private String name;
private int age;
public Student(){}
public Student(String name, int age){
this.name=name;
this.age=age;
}
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age=age;
}
public int getAge(){
return age;
}
@Override
public int compareTo(Student o) {
return -1;
}
}
//按照年龄顺序
public class Student implements Comparable<Student>{
private String name;
private int age;
public Student(){}
public Student(String name, int age){
this.name=name;
this.age=age;
}
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age=age;
}
public int getAge(){
return age;
}
@Override
public int compareTo(Student o) {
int num=this.age-o.age;
return num;
}
}
//反向年龄顺序
public class Student implements Comparable<Student>{
private String name;
private int age;
public Student(){}
public Student(String name, int age){
this.name=name;
this.age=age;
}
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age=age;
}
public int getAge(){
return age;
}
@Override
public int compareTo(Student o) {
int num=o.age-this.age;
return num;
}
}
//年龄相同时，按照名字顺序排序
public class Student implements Comparable<Student>{
private String name;
private int age;
public Student(){}
public Student(String name, int age){
this.name=name;
this.age=age;
}
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age=age;
}
public int getAge(){
return age;
}
@Override
public int compareTo(Student o) {
int num=this.age-o.age;
int num1=num==0?this.name.compareTo(o.name):num;
return num1;
}
}
比较器排序Comparator的应用
//Main.java
import java.util.*;
public class Main {
public static void main(String[] args) {
TreeSet<Student> ss=new TreeSet<Student>(new Comparator<Student>(){
@Override
public int compare(Student s1,Student s2){
int num=s1.getAge()-s2.getAge();
int num2=num==0?s1.getName().compareTo(s2.getName()):num;
return num2;
}
});
Student s1=new Student("lili",19);
Student s2=new Student("zhangliang",20);
Student s3=new Student("wangwu",18);
ss.add(s1);
ss.add(s2);
ss.add(s3);
for(Student s:ss){
System.out.println(s.getName()+","+s.getAge());
}
}
}
//Student.java
public class Student implements Comparable<Student>{
private String name;
private int age;
public Student(){}
public Student(String name, int age){
this.name=name;
this.age=age;
}
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age=age;
}
public int getAge(){
return age;
}
@Override
public int compareTo(Student o) {
int num=this.age-o.age;
int num1=num==0?this.name.compareTo(o.name):num;
return num1;
}
}
案例：成绩排序(比较器排序)
//Main.java
import java.util.*;
public class Main {
public static void main(String[] args) {
TreeSet<Student> ss=new TreeSet<Student>(new Comparator<Student>(){
@Override
public int compare(Student s1,Student s2){
//主要条件
int num=(s2.getYuwen()+s2.getMath())-(s1.getYuwen()+s1.getMath());
//次要条件
int num2=num==0?s1.getYuwen()-s2.getYuwen():num;
int num3=num2==0?s1.getName().compareTo(s2.getName()):num2;
return num3;
}
});
Student s1=new Student("lili",100,98);
Student s2=new Student("zhangliang",20,79);
Student s3=new Student("wangwu",98,76);
ss.add(s1);
ss.add(s2);
ss.add(s3);
for(Student s:ss){
System.out.println(s.getName()+","+s.getYuwen()+","+s.getMath());
}
}
}
//Student.java
public class Student implements Comparable<Student>{
private String name;
private int age;
private int yuwen;
private int math;
public Student(){}
public Student(String name, int age){
this.name=name;
this.age=age;
}
public Student(String name,int yuwen,int math){
this.name=name;
this.yuwen=yuwen;
this.math=math;
}
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age=age;
}
public int getAge(){
return age;
}
public void setYuwen(int yuwen){
this.yuwen=yuwen;
}
public int getYuwen(){
return yuwen;
}
public void setMath(int math){
this.math=math;
}
public int getMath(){
return math;
}
案例：不重复的随机数
//HashSet--->不进行排序
import java.util.*;
public class Main {
public static void main(String[] args) {
Set<Integer> tt=new TreeSet<Integer>();
Random r=new Random();
while(tt.size()<10){
int number=r.nextInt(20)+1;
tt.add(number);
}
for(Integer i:tt){
System.out.println(i);
}
}
}
//TreeSet--->进行大小排序
import java.util.*;
public class Main {
public static void main(String[] args) {
Set<Integer> tt=new HashSet<Integer>();
Random r=new Random();
while(tt.size()<10){
int number=r.nextInt(20)+1;
tt.add(number);
}
for(Integer i:tt){
System.out.println(i);
}
}
}
泛型
好处：1、将运行时期的问题提前到了编译时期；2、避免了强制转换
基础练习：
import java.util.*;
public class Main {
public static void main(String[] args) {
Collection c=new ArrayList();
c.add("hello");
c.add("world");
c.add("java");
c.add(100);
Iterator it=c.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
泛型类
//定义格式
修饰符 class 类名<类型>{}
相关应用：
//DateTest.java
public class DateTest<T>{
private T t;
public T getT(){
return t;
}
public void setT(T t){
this.t=t;
}
}
//Main.java
public class Main {
public static void main(String[] args) {
DateTest<String> ll=new DateTest<String>();
ll.setT("lili");
System.out.println(ll.getT());
DateTest<Integer> i=new DateTest<Integer>();
i.setT(100);
System.out.println(i.getT());
}
}
泛型方法：
//格式
修饰符<类型> 返回值类型方法名(类型 变量名){}
相关应用：
//Main.java
public class Main {
public static void main(String[] args) {
DateTest s=new DateTest();
s.show("hello");
s.show(100);
}
}
//DateTest.java
public class DateTest{
public <T>void show(T t){
System.out.println(t);
}
}
泛型接口
//格式
修饰符 interface 接口名<类型>{}
相关应用：
//Main.java
public class Main {
public static void main(String[] args) {
Fanxing<String> ff=new DateTest<String>();
ff.show("wangwu");
Fanxing<Integer> ii=new DateTest<Integer>();
ii.show(100);
Fanxing<Boolean> bb=new DateTest<Boolean>();
bb.show(true);
}
}
//Fanxing.java
public interface Fanxing<T> {
void show(T t);
}
//DateTest.java
public class DateTest<T> implements Fanxing<T>{
public void show(T t){
System.out.println(t);
}
}
类型通配符
为了表示各种泛型list的父类，可以使用类型通配符
//类型通配符
<?>
//类型通配符的上限（谨代表某一类泛型list的父类）
<?extends类型>
//类型通配符的下限,代表某一类的子类
<?super类型>
相关应用：
//类型通配符
List<?> ll=new ArrayList<>();
List<?> ll2=new ArrayList<Number>();
List<?> ll3=new ArrayList<Integer>();
//类型通配符的上限
List<?extends Number> ll4=new ArrayList<Number>();
List<?extends Number> ll5=new ArrayList<Integer>();
//类型通配符的下限
List<?super Number> ll6=new ArrayList<>();
List<?super Number> ll7=new ArrayList<Number>();
可变参数
用作方法的形参出现，即方法参数可变
//格式
修饰符 返回值类型 方法名(数据类型...变量名){}
相关应用：
public class Main {
public static void main(String[] args) {
System.out.println(sum(10));
System.out.println(sum(10,20));
System.out.println(sum(10,20,30));
}
public static int sum(int ...a){
int sum=0;
for(int i:a){
sum+=i;
}
return sum;
}
}
注意：如果需要将某个普通参数与可变参数放到一起，则需要将可变参数放到普通参数的后面。
可变参数的使用：
public static <T>list<T> asList(T...a);//返回由指定数组支持的固定大小的列表
List<String> list=Arrays.asList("hello","world","java");
//该方法构造的列表，不能通过add和remove的操作，能进行set操作。
public static <E>list<E> of(E...elements);//返回包含任意数量元素的不可变列表
List<String> ll=List.of("hello","world","java");
//该方法构造的列表，不能通过add和remove的操作，set操作也不行。
public static <E>Set<E> of(E..elements);//返回一个包含任意数量元素的不可变集合
Set<String> ll1=Set.of("hello","world","java");
//该方法构造的列表，不能通过add和remove的操作,没有set操作；不能出现重复的元素
Map集合
interface Map<K,V> //K:键的类型 V:值的类型
//不可重复，一一对应，呈映射关系
相关应用：
//添加元素
Map<String,String> mm=new HashMap<String,String>();
mm.put("20214063","liuzijin");//添加元素
mm.put("20214056","liuyichen");//添加元素
mm.put("20214063","wangwu");//修改已有键的元素--->代替
System.out.println(mm);
Map集合基本功能：
V put(K key,V value);//添加元素
V remove(Object key);//根据键删除键值对元素
void clear();//移除所有的键值对元素
boolean containsKey(Object key);//判断集合是否包含指定的键
boolean containsValue(Object value);//判断集合是否包含指定的值
boolean isEmpty();//判断集合是否为空
int size();//集合的长度，也就是集合中键值对的个数
相关应用：
Map<String,String> map=new HashMap<String,String>();
//添加元素
map.put("1","wo");
//移除元素
map.remove("1");//System.out.println("1");---->会输出wo
//清空元素
map.clear();
//判断集合是否包含指定的键
System.out.println(map.containsKey("1"));
//判断集合是否包含指定的值
System.out.println(map.containsValue("1"));
//判断集合是否为空
System.out.println(map.isEmpty());
//得到集合长度
System.out.println(map.size());
Java笔记第二弹的更多相关文章
- 菜鸡的Java笔记 第二十八 - java 包的定义
包的主要作用以及定义 包的导入操作 系统常见的开发包 jar 程序命令 包的定义 在任何的操作系统之中都有一个统一的共识:同一个目录下不能够存在有相同的文 ...
- Java基础の第二弹 基础语法
Java关键字 • abstract:表明类或类中的方法是抽象的:• boolean:基本数据类型之一,布尔类型:• break:提前跳出一个块:• byte:基本数据类型之一,字节类型:• ...
- 菜鸡的Java笔记第二 - java 数据类型
1.程序的本质实际上就是在于数据的处理上. JAVA中的数据类型有两类 基本数据类型:是进行内容的操作而不是内存的操作 数值型: 整型:byte(-128 ~ 127),short(-32768 ~ ...
- 菜鸡的Java笔记 第二十七 - java 链表基本概念
链表基本概念 1.链表的基本形式 2.单向链表的完整实现 认识链表 链表= 可变长的对象数组,属于动态对象数组的范畴 链表 ...
- 菜鸡的Java笔记 第二十六 - java 内部类
/* innerClass 从实际的开发来看,真正写到内部类的时候是在很久以后了,短期内如果是自己编写代码,几乎是见不到内部类出现的 讲解它的目的第一个是为了解释概念 ...
- 菜鸡的Java笔记 第二十五 wrapperClass 包装类
wrapperClass 包装类 1.包装类的特点 2.装箱与拆箱操作 3.数据转型处理 内容 Object 类可以接收 ...
- 菜鸡的Java笔记 第二十四 - java 接口的基本定义
1.接口的基本定义以及使用形式 2.与接口有关的设计模式的初步认识 3.接口与抽象类的区别 接口与抽象类相比,接口的使用几率是最高的,所有的 ...
- 菜鸡的Java笔记 第二十三 - java 抽象类的概念
abstractClass 抽象类的概念 1.抽象类的基本定义 2.抽象类的使用原则 不会抽象类与接口,java = 没学 ...
- 菜鸡的Java笔记 第二十二 - java 对象多态性
本次只是围绕着多态性的概念来进行讲解,但是所讲解的代码与实际的开发几乎没有关系,而且多态一定是在继承性的基础上才可以操作的, 而本次将使用类继承的关系来描述多态的性质,实际的开发中不会出 ...
- PHPCMS笔记第二弹
熟练地使用PHPCMS可以插入模板,将静态站转变为动态站也更加方便,多加练习还是有好处的 将index.html的头和尾拆分出来,分别放在header.html和footer.html文件夹中,这三个 ...
随机推荐
- 《Unix/Linux系统编程》第十三章学习笔记 20201209戴骏
TCP/IP协议 从字面意义上讲,有人可能会认为 TCP/IP 是指 TCP 和 IP 两种协议.实际生活当中有时也确实就是指这两种协议.然而在很多情况下,它只是利用 IP 进行通信时所必须用到的协议 ...
- How to Check and Repair EXT4 Filesystem in Linux
The fsck (stands for File System Consistency Check) is used to check and repair one or more Linux fi ...
- 2D 消隐效果
在触发消隐的物体(比如玩家)挂下面的代码,以及box collider,rigidbody 2d using UnityEngine; public class ColliderFader : Mon ...
- Delphi7_VCL线程的使用（一）
1.TThread类的属性 (1)FreeOnTerminate属性 该属性用于指定当前的线程终止时是否自动删除线程对象.默认值为true. 语法: 1 Property FreeOnTerminat ...
- JLink OB SWI 取代串口打印的方式
1:debug的串口被占用 2:从Keil 迁移到的LINUX下开发. 3:手上只有JLinkOB,(4线:CLK,SWIO,GND,RST) 4:设备只引出了4线(SWO 没接出) 环境: JLin ...
- springboot 整合 oss
一.阿里云配置 获取 accessKeyIdaccessSecret 创建桶 bucketName 二.demo 1.oss.config import org.springframework.bea ...
- HTTP身份认证
1.HTTP Basic认证 用户每次发送请求的时候,在请求头中携带能通过认证的身份信息:Authorization: <username>:<password> 1.1 交互 ...
- 医学分割 不确定性 2019 MICCAI
z今天分享一篇发表在MICCAI 2019上的论文: Uncertainty-aware Self-ensembling Model for Semi-supervised 3D Left Atriu ...
- 延期！欧盟新标EN IEC 62368-1:2020延至2024年7月6日生效
近日,TC108X成员投票同意将EN IEC 62368-1:2020(对应IEC 62368-1第三版)的DOW (Date Of Withdrawn)日期由原先的2023年1月6日延长至2024年 ...
- 源代码管理工具：Github
GitHub是一个基于Git的进行版本控制的代码托管网站. Git指的是是一个开放源代码版本控制系统,由Linus Torvalds启动.在时间的累积下,现在的Github是一个最大的开源软件社区.在 ...