# Day17-Java基础

Posted zsr6135

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了# Day17-Java基础相关的知识，希望对你有一定的参考价值。

Day17-Java

文章目录

1、类集

1.1 认识类集

如果现在要想保存多个对象，肯定使用对象数组完成，但是对象数组本身有一个最大问题在于确定了数据的长度，所以后来使用了链表完成了动态对象数组的开发，可是链表的开发难度实在是很大，而且如果一个链表要想真正的去使用，只依靠之前多编写的还不够，还需要进行一些代码的调优。

而在JDK1.2之后正式引入了类集的概念，类集是一种动态的对象数组，属于各个数据结构的实现类，在整个类集之中主要的组成是一些核心的操作接口：Collection,List,Set,Map,Iterator,Enumeration。

1.2 Collection集合接口

Collection是单个集合保存最大的父接口。而在Collection接口的定义如下：

public interface Collection<E> extends Iterable<E>

从JDK1.5之后Collection接口上追加有泛型应用，这样的直接好处就是避免了ClassCastException异常，里面的所有的数据的保存类型应该是相同的。对于此类的常用方法有如下几个：

方法名称类型描述
public boolean add(E e)普通向集合中添加数据
boolean addAll(Collection<? extends E> c)普通向集合添加一组数据
public void clear()普通清空集合数据
public boolean contains(Object o)普通查询数据是否存在
public Boolean isEmpty()普通判断集合是否有元素
public Iterator iterator()普通取得Iterator接口对象，用于输出
public boolean remove(Object o)普通删除数据，需要equals()方法
public int size()普通取得集合的长度
public Object[] toArray()普通将集合数据返回

在开发之中，add()和iterator()方法使用率极高，其他的方法几乎使用不到。接口只是一个存储数据的标准，而并不能区分存储类型，例如：如果要存放数据可能需要区分重复与不重复。所以在实际的开发之中，往往会去考虑使用Collection接口的子接口：List（允许重复）、Set（不允许重复）。

1.3 List接口简介

List是Collection的一个最常用的子接口，并且允许重复的子接口。

方法名称类型描述
public E get(int index)普通取得指定索引位置上的数据
public E set(int index,E element)普通修改指定索引上的数据
public ListIterator listIterator()普通为ListIterator接口实例化

List子接口与Collection接口相比最大的特点在于其有一个get()方法，可以根据索引取得内容。但是List本身还属于我们的一个接口而如果取得接口的实例化对象就必须有子类，在List接口下有三个常用子类：ArrayList、Vector、LinkedList。

最终的操作应该还是以接口为主，那么既然要以接口为主，所以所有的方法只参考接口的定义即可。

1.3.1 ArrayList子类

ArrayList是一个针对于List接口的数组操作实现。

List基本操作

package com.day17.demo;

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

public class ArrayListDemo {
	public static void main(String[] args) {
		List<String> all = new ArrayList<>();//此时集合里面只适合保存String类型数据
		System.out.println(all.size() + " " + all.isEmpty());
		all.add("Hello");
		all.add("Hello");	//重复数据
		all.add("world~!");
		all.add("zsr~");
		System.out.println(all.contains("zsr~"));
		System.out.println(all.contains("zsr"));
		System.out.println(all);
	}
}

通过我们的代码我们可以证实List允许保存重复数据。

List中存在get()方法，可以利用get()方法结合索引取得数据。

List的get()方法

package com.day17.demo;

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

public class ArrayListDemo {
	public static void main(String[] args) {
		List<String> all = new ArrayList<>();//此时集合里面只适合保存String类型数据
		all.add("Hello");
		all.add("Hello");	//重复数据
		all.add("world~!");
		all.add("zsr~");
		for (int i = 0; i < all.size(); i++) {
			System.out.println(all.get(i));
		}
	}
}

但是千万记住，get()方法是List子接口的，如果现在使用不是List而是Collection，对于此时的数据取出，只能够将集合变为对象数组的操作了。

(开发一般不使用)Collection进行输出处理并取出数据

package com.day17.demo;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;

public class CollectionDemo {
	public static void main(String[] args) {
		Collection<String> all = new ArrayList<>();//此时集合里面只适合保存String类型数据
		all.add("Hello");
		all.add("Hello");	//重复数据
		all.add("world~!");
		all.add("zsr~");
		//操作以Object形式返回，那么就有可能需要向下转型，有可能造成ClassCastException的安全隐患
		Object result [] = all.toArray();//变为Object对象数组
		System.out.println(Arrays.toString(result));
	}
}

集合与简单Java类

在实际的开发之中，集合里面保存最多的数据类型，就是简答java类。

向集合保存简单java类

package com.day17.demo;

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

class Person{
	private String name;
	private Integer age;
	public Person(String name, Integer age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	@Override
	public boolean equals(Object obj) {
		// TODO Auto-generated method stub
		if(this == obj){
			return true;
		}
		if (obj == null){
			return false;
		}
		if(!(obj instanceof Person)){
			return false;
		}
		Person per = (Person) obj;//这个对象自己操作可以向下转型
		return this.name.equals(per.name) && this.age.equals(per.age);
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	
}
public class ListDemo {
	public static void main(String[] args) {
		List<Person> all = new ArrayList<>();
		all.add(new Person("张三",10));
		all.add(new Person("李四",21));
		all.add(new Person("王五",19));
		//对于remove()、contains()方法必须类中有equals()的支持
		all.remove(new Person("李四",21));
		System.out.println(all.contains(new Person("李四",21)));
		for (int i = 0; i < all.size(); i++) {
			System.out.println(all.get(i));
		}
	}
}

该List集合如果使用remove()、contains()方法必须有equals()方法的支持。简单的java类里面的使用是很少使用。

1.3.2 Vector子类

Vector是旧的子类，这个类是从JDK1.0退出，ArrayList实在JDK1.2推出。

package com.day17.demo;

import java.util.ArrayList;
import java.util.List;
import java.util.Vector;

public class ArrayListDemo {
	public static void main(String[] args) {
		List<String> all = new Vector<>();//此时集合里面只适合保存String类型数据
		all.add("Hello");
		all.add("Hello");	//重复数据
		all.add("world~!");
		all.add("zsr~");
		for (int i = 0; i < all.size(); i++) {
			System.out.println(all.get(i));
		}
	}
}

面试题：请解释ArrayList与Vector区别？

区别ArrayListVector
历史时间JDK1.2JDK1.0
处理形式异步处理，形式更高同步处理，性能降低
数据安全非线程安全线程安全
输出形式Iterator、ListIterator、foreachIterator、ListIterator、foreach、Enumeration
1.3.3LinkedList子类

在List接口里面还有一个LinkedList子类，如果向我们的父接口转型的话，使用的形式和之前没有任何的区别。

package com.day17.demo;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class ArrayListDemo {
	public static void main(String[] args) {
		List<String> all = new LinkedList<>();//此时集合里面只适合保存String类型数据
		all.add("Hello");
		all.add("Hello");	//重复数据
		all.add("world~!");
		all.add("zsr~");
		for (int i = 0; i < all.size(); i++) {
			System.out.println(all.get(i));
		}
	}
}

面试题：请解释ArrayList与LinkedList区别？

区别ArrayListLinkedList
构造方法public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}		public LinkedList() {
}
开辟长度开辟定长的大小动态开辟
时间复杂度时间复杂度为1时间复杂度为n

1.4 Set接口简介

Set接口与List接口最大的区别就是内容是不允许重复的，通知Set和List最大的区别还有一个就是

set接口没有对Collection接口进行扩充，而List对Collection接口进行了扩充。由于jdk1.8的原因，所以在collection接口也提供有一些default方法，而这写方法并没有在Set接口里面出现。也就是说set接口里面不可能使用get()方法进行处理，而在Set子接口里面有我们常用的子类HashSet、TreeSet。

1.4.1 散列存放的子类：HashSet

Hash(哈希)属于一种算法，这种算法的核心意义指的是找空保存算法，所以只要一看见Hash就是说没有顺序的保存。

观察Set接口的使用

package com.day17.demo;

import java.util.HashSet;
import java.util.Set;

public class HashSetDemo {
	public static void main(String[] args) {
		Set<String> all = new HashSet<>();
		all.add("Hello");
		all.add("zsr");
        all.add("zsr");
		all.add("Abc");
		System.out.println(all);
	}
}

保存数据在输出之后发现，重复的数据没有了，并且其本身的保存也是没有任何顺序的。

1.4.2 排序存放的子类：TreeSet

如果现在希望Set集合之中保存的数据有顺序，那么就通过TreeSet进行Set接口的实例化。

使用TreeSet实例化接口

package com.day17.demo;

import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;

public class HashSetDemo {
	public static void main(String[] args) {
		Set<String> all = new TreeSet<>();
		all.add("C");
		all.add("C");
		all.add("A");
		all.add("B");
		all.add("D");
		System.out.println(all);
	}
}

现在发现所有的保存的数据没有重复且有顺序。TreeSet使用的是一个升序排列的模式完成的。

1.4.3 关于TreeSet排序的说明

通过之前的程序可以发现，使用TreeSet实例化Set接口之中，所有保存的数据都是有序的，那么在这种情况下，那么如果说使用一个自定义的类呢?

那么这个时候如果这个类的对象要进行排序的话，则这个类必须实现Comparable接口，设置比较规则，但是在这种情况下有一点必须注意：一旦使用了Comparable的话，类之中所有的属性都必须写进排序规则。

自定义排序

package com.day17.demo;

import java.util.Set;
import java.util.TreeSet;
class Personn implements Comparable<Personn>{
	private String name;
	private Integer age;
	
	public Personn(String name, Integer age) {
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "person [name=" + this.name + ", age=" + this.age + "]\\n";
	}
	@Override
	public int compareTo(Personn o) {
		// TODO Auto-generated method stub
		if(this.age > o.age){
			return 1;
		}else if (this.age < o.age){
			return 0;
		}else{
			return this.name.compareTo(o.name);
		}
		
	}
	
}
public class TreeSetDemo {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Set<Personn> all=new TreeSet<Personn>();
		all.add(new Personn("张三",20));
		all.add(new Personn("张三",20));
		all.add(new Personn("李四",20));
		all.add(new Personn("王五",30));
		all.add(new Personn("赵六",40));
		System.out.println(all);
	}
}

因为在实际开发之中TreeSet的使用实在是过于麻烦了，在项目开发的简单java类是根据数据库表的设计而来的，如果一张数据表的字段过多，你这个类得写死。

TreeSet子类依靠Compara()方法的返回值是否为0来判断是否为重复元素.

1.4.4 关于重复元素的说明

在使用TreeSet子类进行数据保存的时候，重复元素的判断依靠的是Comparable接口完成的。这并不是全部Set接口判断重复元素的方式，因为如果使用的是HashSet子类，由于其Comparable没有任何关系，所以他判断重复重复元素的主要依靠的是两个方法：

  • hash码：public int hashCode();
  • 对象比较：public Boolean equals(Object obj)

在进行对象比较的过程之中，首先会使用hashCode()与保存在集合之中的对象的hashCode()进行比较，如果代码相同，则再使用equals()方法进行内容的比较，如果全部相同，则为相同元素。

package com.day17.demo;

import java.util.Set;
import java.util.TreeSet;
class Personn implements Comparable<Personn>{
	pr
以上是关于# Day17-Java基础的主要内容，如果未能解决你的问题，请参考以下文章
 

 day06-jsp


 [vscode]--HTML代码片段（基础版，reactvuejquery）


 [Go] 通过 17 个简短代码片段，切底弄懂 channel 基础


 AI基础_Day02


 Java基础Day5


 python基础-day9-函数