我是靠谱客的博主 谦让小霸王，最近开发中收集的这篇文章主要介绍Java-数据结构-Set-List数据结构: 栈结构 先进后出,后进先出数组结构:查询快,增删慢链表结构: 查询慢,增删快Set接口:哈希表:可变参:定义方法时使用: 修饰符 返回值类型 方法名 (数据类型…变量名){} 底层就是一个数组,根据参数个数不同,会创建不通长度的数组,来存储这些参数 传递的参数,可以是0个,也可以是多个。 一个方法的参数列表,只能有一个可变参数 如果方法的可变参数有多个,那么可变参数必须写在参数列表的末尾 特殊写法: public static void metho，觉得挺不错的，现在分享给大家，希望可以做个参考。
概述
数据结构: 栈结构 先进后出,后进先出
入口和出口在同一侧,存储元素到集合-入栈(压栈)
类似子弹的弹夹,入栈123,出栈321
队列结构: 先进先出,后进后出
排队安检,储存123,取出123
数组结构:查询快,增删慢
数组的地址是连续的,我们通过数组的首地址可以找到数组,通过索引可以快速查找到某一个元素
数组 的长度是固定的,我们想增加,删除,不许创建一个新的数组,把数组的数据复制过来
把新数组的地址值赋值给变量arr,源数组会在内存中被销毁
在堆内存中,频繁的创建数组,复制数组中的元素,销毁数组,效率低下
链表结构: 查询慢,增删快
链表中的地址不是连续的,每次查询都必须从头开始查询
链表结构增加或者删除一个元素,对链表的整体结构没有影响,所以增删快
链表每一个元素称之为节点,一个节点包含了一个数据源(存储数组),两个指针域(存储域)
自己的地址-数组-下一个节点的地址
单向链表:链表中只有一条链,不能保证元素的顺序(存储元素和取出元素的顺序可能不一致)
双向链表:链表中有两条链,有一条链子专门记录元素的顺序,是一个有序的集合
红黑树: 趋近于平衡树,查询快查询叶子节点最大次数和最小次数不能超过2倍
节点可以是红色或者黑色的,根节点是黑色的,叶子节点(空节点)是黑色每个红色节点的子节点是黑色的
任何一个节点到其中每一个叶子节点的所有路径上黑色节点数相同
树形结构:
二叉树:分支不能超过两个,左孩子(左子树)|右孩子(右子树)
排序树/查找树:在二叉树的基础上,元素是有大小顺序的,左子树小,右子树大
平衡树:左孩子和右孩子数量相等
不平衡树:左孩子不等于右孩子的数量
Set接口:
同样继承Connection,不允许存储重复元素,没有索引,不能使用普通for循环遍历
java.util.HashSet集合 implements Set接口
只能通过迭代器或者增强for来遍历集合。
集合的遍历首选增强for
其次使用迭代器
最后看集合是否有索引，有就可以使用for循环来遍历。
HashSet:
不允许存储重复元素,没有索引,不能使用普通for循环遍历
是一个无序的集合,存储和取出的顺序有可能不一致
底层是一个哈希表结构,查询的数度非常快
============================
public class HashSetCls {
public static void main(String[] args) {
Set<Integer> set = new HashSet<>();
set.add(1);
set.add(3);
set.add(2);
set.add(4);
set.add(1);
//使用迭代器
Iterator<Integer> it = set.iterator();
while(it.hasNext()){
//取出的顺序不是一致的
Integer n = it.next();
System.out.println(n);
}
System.out.println("-----------------");
//使用增强for
for (Integer integer : set) {
System.out.println(integer);
}
}
}
----------------------------------------------------
import java.util.HashSet;
/*
* set集合不允许存储重复元素
* set集合在调用add方法的时候,add方法会调用元素的hashCode方法和equals方法,判断元素是否重复
* 发现没有,就会存储.
*
*
*/
public class HashSetSave {
public static void main(String[] args) {
//创建
HashSet<String> set = new HashSet<>();
String s1 = new String("abc");
String s2 = new String("abc");
set.add(s1);
set.add(s2);
set.add("重地");
set.add("通话");
set.add("abc");
System.out.println(set);
}
}
哈希表:
哈希值:
是一个十进制的整数,由系统随机给出(就是对象的地址,是一个逻辑地址,是模拟出来得到地址,不是数据实际存储的物理地址)
在Object类中,获取对象的哈希值
int hashCode() 返回该对象的哈希码值.
hashCode方法的源码:
public native int hashCode();
native:代表该方法调用的是本地操作系统的方法
jdk1.8之前hash表=数组+链表
jdk1.8之后哈希表=数组+链表 | 哈希表=数组+红黑树(提高查询的速度)
如果链表的长度超过啦8位,那么就会把链表转换为红黑树(提高查询的速度)
数组结构:把元素进行分组(相同的hash值元素是一组)
链表结构是把相同的哈希值元素连接到一起
两个元素不同,但是hash值相同,叫哈希冲突
================================
public class Person {
private String name;
private int age;
public Person() {
super();
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return this.name + this.age;
}
//这应该是一个固定的写法。
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
//添加hashCode和equals方法.
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
//重写hashCode方法
public int hashcode(){
return 1;
}
}
-----------------------------------------------------
public class HashCodeDemo {
public static void main(String[] args) {
//Person 继承自 Object, 所以可以使用Object中hashCode方法
Person p1 = new Person();
int h1 = p1.hashCode();
System.out.println(h1);
/*
* toString 方法的源码:
* return getClass.getName()+"@"+Integer.toHexString(hashCode());
*
*/
Person p2 = new Person();
int h2 = p2.hashCode();
System.out.println(h2);
System.out.println(p1);
System.out.println(p2);
System.out.println(p1==p2);//false
/*
* String类的hash值
* String类重写Object类的hashCode方法
*
*/
String s1 = new String("abc");
String s2 = new String("abc");
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());
System.out.println("重地".hashCode());
System.out.println("通话".hashCode());
}
}
-------------------------------------------------------------------
import java.util.HashSet;
/*
* HashSet存储自定义元素
* set集合保证元素唯一
* 存储的元素(String,Integer,.....Student)必须重写hashCode方法和equals方法
*
* 要求:
* 同名同年龄的人,视为同一个人,只能存储一次
*
*/
public class HashSetZiDingYi {
public static void main(String[] args) {
//创建HashSet集合存储Person
HashSet<Person> set = new HashSet<>();
Person p1 = new Person("小美女",18);
Person p2 = new Person("小美女",18);
Person p3 = new Person("小美女",19);
set.add(p1);
set.add(p2);
set.add(p3);
System.out.println(set);
}
}
------------------------------------------------------------
import java.util.HashSet;
import java.util.LinkedHashSet;
/*
* java.util.LinkedHashSet集合 extends HashSet集合
* LinkedHashSet集合特点:
* 底层是一个哈希表(数组+加链表/红黑树)+链表:多了一条链表(记录元素的存储顺序),保证元素有序
*
*
*
*/
public class LinkedHashSetCls {
public static void main(String[] args) {
//无序不重复
HashSet<String> set = new HashSet<>();
set.add("abc");
set.add("abc");
set.add("www");
set.add("it");
set.add("cast");
System.out.println(set);
System.out.println("--------------------");
//有序不允许重复
LinkedHashSet<String> linked = new LinkedHashSet<>();
linked.add("www");
linked.add("abc");
linked.add("abc");
linked.add("itcast");
System.out.println(linked);
}
}
可变参:
jdk1.5之后出现的新特性
当方法的参数列表数据类型已经确定,参数的个数不确定
定义方法时使用:
修饰符 返回值类型 方法名 (数据类型…变量名){}
底层就是一个数组,根据参数个数不同,会创建不通长度的数组,来存储这些参数
传递的参数,可以是0个,也可以是多个。
一个方法的参数列表,只能有一个可变参数
如果方法的可变参数有多个,那么可变参数必须写在参数列表的末尾
特殊写法:
public static void method(Object…obj){}
public class KeBianCan {
public static void main(String[] args) {
// int i = add();
// System.out.println(i);
//传一个参数
int i = add(10);
System.out.println(i);
int i2 = add(10,20);
System.out.println(i2);
}
/*
* 可变参:
* 定义计算(0-n)整数的和的方法
* 但是参数个数不确定,就可以使用可变参
*
*/
public static int add(int...arr){
// System.out.println(arr);//[I@15db9742,底层是一个数组
// System.out.println(arr.length);
//定义一个初始化的变量,记录累加求和
int sum =0;
//遍历数组,获取数组中的每一个元素
for (int i : arr) {
//累加求和
sum+=i;
}
return sum;
}
//定义一个方法,计算两个int类型的整数的和
// public static int add(int a,int b){
// return a+b;
// }
//定义一个方法,计算三个int类型的整数的和
// public static int add(int a,int b,int c){
// return a+b+c;
// }
}
List接口:
list接口的链表实现:
继承自Collection
是一个有序的集合,有索引的,允许存储重复元素
java.util.list 接口 extends Collection接口
public void add(int index, E element):将指定的元素,添加到该集合中指定位置，索引为三的变成它，其他的往后挪。
public E get(int index):返回集合中指定位置的元素
public E remove(int index):移除列表中指定索引位置的元素,返回被移除的元素
public E set(int index,E element):用指定的元素替换集合中指定位置的元素,返回值是更新前的元素
操作索引一定要防止索引越界异常.
public class ListCls {
public static void main(String[] args) {
//创建
List<String> list = new ArrayList<>();
//添加元素
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("e");
//打印
System.out.println(list);//不是地址,重写了toString
//在c和d之间添加
list.add(3, "itheima");
System.out.println(list);
//移除指定索引处的元素
String remove = list.remove(2);
System.out.println("被移除的元素"+remove);
//set用指定元素替换集合中指定位置的元素,返回值是更新前的元素
//把e替换为E,返回被替换的元素
String set = list.set(4, "E");
System.out.println("被替换的元素"+set);
//list集合遍历
//普通for循环
for(int i=0;i<list.size();i++){
String s = list.get(i);
System.out.println(s);
}
System.out.println("----------------------");
//使用迭代器
Iterator<String> it = list.iterator();
while(it.hasNext()){
String next = it.next();
System.out.println(next);
}
System.out.println("-----------------");
//增强for,最简单
for (String string : list) {
System.out.println(string);
}
}
}
LinkedList:
大量操作首位元素的方法
java.util.LinkedList 集合 implements List 集合
LinkedList集合的特点:
底层是一个链表结构,查询慢,增删快
里面包含大量操作首位元素的方法
使用LinkedList集合特有的方法,不能使用多态
public void addFirst(E e):将指定元素插入此列表的开头
public void addLast(E e):将指定元素插入此列表的结尾
public E getFirst():返回此列表的第一个元素
public E getLast():返回此列表的最后一个元素
public E removeFirst():移除并返回此列表的第一个元素
public E removeLast():移除返回此列表的最后一个元素
public E pop():从此列表所表示的堆栈处弹出一个元素
public void push(E e):将元素推入此列表所表示的堆栈
不包含返回的是true:
public boolean isEmpty():如果列表不包含元素,则返回true
public class LinkedListCls {
public static void main(String[] args) {
// show01();
// show02();
show03();
}
public static void show01(){
//创建
LinkedList<String> linked = new LinkedList<>();
linked.add("a");
linked.add("b");
linked.add("c");
linked.add("d");
linked.add("e");
System.out.println(linked);
//放在开头 等效于push,这两个方法相同。
linked.addFirst("www");
System.out.println(linked);
linked.push("www");
System.out.println(linked);
//放在结尾
linked.addLast("com");
System.out.println(linked);
}
public static void show02(){
//创建
LinkedList<String> linked = new LinkedList<>();
linked.add("a");
linked.add("b");
linked.add("c");
linked.add("d");
linked.add("e");
System.out.println(linked);
//清空
linked.clear();//执行这条下面会爆出异常,所以要加条件判断
//判断集合是否为空,取反在进行获取元素
if(!linked.isEmpty()){
//获取第一个
String first = linked.getFirst();
System.out.println(first);
//获取最后一个
String last = linked.getLast();
System.out.println(last);
}
}
public static void show03(){
//创建
LinkedList<String> linked = new LinkedList<>();
linked.add("a");
linked.add("b");
linked.add("c");
linked.add("d");
linked.add("e");
System.out.println(linked);
String removeFirst = linked.removeFirst();
String pop = linked.pop();//作用同上 String removeFirst = linked.removeFirst();
//这一遍把b也移除掉了，所以返回的只有c 和 d 了。
System.out.println("被移除的第一个元素"+removeFirst);
String removeLast = linked.removeLast();
System.out.println("被移除的第一个元素"+removeLast);
System.out.println(linked);
}
}
---------------------------------------------------
/*
* Vector:可以实现可增长的对象数组
* 同步的,单线程,慢
* 也实现了List接口.
*
*/
public class VectorCls {
}
------------------------------------------------
/*
* 此实现不是同步的,
*/
public class ArrayListCls {
}
最后
以上就是谦让小霸王为你收集整理的Java-数据结构-Set-List数据结构: 栈结构 先进后出,后进先出数组结构:查询快,增删慢链表结构: 查询慢,增删快Set接口:哈希表:可变参:定义方法时使用: 修饰符 返回值类型 方法名 (数据类型…变量名){} 底层就是一个数组,根据参数个数不同,会创建不通长度的数组,来存储这些参数 传递的参数,可以是0个,也可以是多个。 一个方法的参数列表,只能有一个可变参数 如果方法的可变参数有多个,那么可变参数必须写在参数列表的末尾 特殊写法: public static void metho的全部内容，希望文章能够帮你解决Java-数据结构-Set-List数据结构: 栈结构 先进后出,后进先出数组结构:查询快,增删慢链表结构: 查询慢,增删快Set接口:哈希表:可变参:定义方法时使用: 修饰符 返回值类型 方法名 (数据类型…变量名){} 底层就是一个数组,根据参数个数不同,会创建不通长度的数组,来存储这些参数 传递的参数,可以是0个,也可以是多个。 一个方法的参数列表,只能有一个可变参数 如果方法的可变参数有多个,那么可变参数必须写在参数列表的末尾 特殊写法: public static void metho所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
发表评论 取消回复