Java教程
Java笔记第二弹
本文主要是介绍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笔记第二弹的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
您可能喜欢
-
Springboot应用的多环境打包入门11-23
-
Springboot应用的生产发布入门教程11-23
-
Python编程入门指南11-23
-
Java创业入门：从零开始的编程之旅11-23
-
Java创业入门：新手必读的Java编程与创业指南11-23
-
Java对接阿里云智能语音服务入门详解11-23
-
Java对接阿里云智能语音服务入门教程11-23
-
JAVA对接阿里云智能语音服务入门教程11-23
-
Java副业入门：初学者的简单教程11-23
-
JAVA副业入门：初学者的实战指南11-23
-
JAVA项目部署入门：新手必读指南11-23
-
Java项目部署入门：新手必看指南11-23
-
Java项目部署入门：新手必读指南11-23
-
Java项目开发入门：新手必读指南11-23
-
JAVA项目开发入门：从零开始的实用教程11-23
栏目导航
