2021-06-07复习java
一、常见的数据结构
栈（先进后出）
队列
- 队列:queue,简称队，它同堆栈一样，也是一种运算受限的线性表，其限制是仅允许在表的一端进行插入，
而在表的另一端进行删除。
简单的说，采用该结构的集合，对元素的存取有如下的特点∶
-
先进先出(即，存进去的元素，要在后它前面的元素依次取出后，才能取出该元素)。例如，小火车过山洞，车头先进去，车尾后进去;车头先出来，车尾后出来。
-
队列的入口、出口各占一侧。例如，下图中的左侧为入口，右侧为出口。
数组
- 数组:Array,是有序的元素序列，数组是在内存中开辟一段连续的空间，并在此空间存放元素。就像是一排出租屋，有100个房间，从001到100每个房间都有固定编号，通过编号就可以快速找到租房子的人。
简单的说,采用该结构的集合，对元素的存取有如下的特点∶
查找元素快︰ 通过索引，可以快速访问指定位置的元素
增删元素慢： 指定索引位置增加元素∶需要创建一个新数组，将指定新元素存储在指定索引位置，再把原数组元素根据索引，复制到新数组对应索引的位置
链表
- 链表:linked list,由一系列结点node (链表中每一个元素称为结点）组成，结点可以在运行时i动态生成。每个结点包括两个部分︰一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。我们常说的链表结构有单向链表与双向链表，那么这里给大家介绍的是单向链表。
简单的说，采用该结构的集合，对元素的存取有如下的特点︰
-
多个结点之间，通过地址进行连接。 例如，多个人手拉手，每个人使用自己的右手拉住下个人的左手，依次类推，这样多个人就连在一起了。
-
查找元素慢︰ 想查找某个元素，需要通过连接的节点，依次向后查找指定元素
-
增删元素快∶ 增加元素:只需要修改连接下个元素的地址即可。
红黑树
- 二叉树: binary tree ,是每个结点不超过2的有序树( tree ) 。
简单的理解，就是一种类似于我们生活中树的结构，只不过每个结点上都最多只能有两个子结点。二叉树是每个节点最多有两个子树的树结构。顶上的叫根结点，两边被称作"左子树"和“右子树”。
二、List集合_介绍&常用方法
- List集合是有序的 collection(也称为序列)。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引√(在列表中的位置)访问元素，并搜索列表中的元素。
java.util.List接口extends collection接口list接口的特点:
-
1.有序的集合,存储元素和取出元素的顺序是一致的(存储123取出123)
-
2.有索引包含了一些带素引的方法
-
3.允许存储重复的元素
List接口中带索引的方法(特有)
- public void add(int index，E element):将指定的元素，添加到该集合中的指定位置上。- public E get(int index):返回集合中指定位置的元素。
- public E remove(irkt index):移除列表中指定位置的元素，返回的是被移除的元素。
- public E set(int index，E eLement):用指定元素替换集合中指定位置的元素,返回值的更新前的元素。注意:
操作索引的时候,一定要防止索引越界异常
public static void main(string[]args) {
//创建一个List集合对象,多态
List<String>.list = new_ArrayList<>();//使用add方法往集合中添加元素
list.add( e: "a");
list.add( "b");
list.add("c");
list.add( "d");
list.add("a");//打印集合
system.out.println(list);//[a， b， c， d，a]不是地址重写了tostring
add(int index，E element)方法：
// public void add(int index，E element):将指定的元素，添加到该集合中的指定位置上。//在c和d之间添加一个小张
list.add( index: 3，element: "小张" );//[a， b， c， 小张， d，a]
system.out.printin(list);//[a， b， c， 小张， d，a]
remove(int index)方法:
/ / public E remove(int index):移除列表中指定位置的元素，返回的是被移除的元素。//移除元素
String removeE = list.remove( index: 2);
system.out.println(“被移除的元素:"+removeE);//被移除的元素:cSystem.out.println(list); / /[a, b, 小张, d, a]
set(int index，E eLement):方法
//public E set(int index，E eLement):用指定元素替换集合中指定位置的元素,返回值的更新前的元素。
//把最后一个a,替换为4
string setE - list.set( 4,"A");
system.out.println("被替换的元素: "+setE);//被替换的元素:a
system.out.println(list);//[a, b, 小张, d，A]
get方法:(返回集合中得元素)
//lList集合遍历有3种方式//使用普通的for循环
for(int i=e; i<list.size(; i++){
// public E get(int index):返回集合中指定位置的元素。
string s = list.get(i);
System.out.println(s);
}
system.out.println("------");
//使用迭代器
Iterator<String> it = list.iterator();
while(it.hasNext(){
string s=it.next();
system.out.println(s);
}
system.out.println("------");
//使用增强for
for ( string s : list) {
system.out.println(s);
}
ArrayList集合
- java.util.ArrayList集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用最多的功能为查询数据、遍历数据，所以ArrayList是最常用的集合。
- 许多程序员开发时非常随意地使用ArrayList完成任何需求，并不严谨，这种用法是不提倡的。
Linkedlist集合
java.util.Linkedlist集合impLements list接口LinkedList集合的特点:
-
1.底层是一个链表结构:查询慢,增删快
-
2.里边包含了大量操作首尾元素的方法
-
注意: 使用LinkedList集合特有的方法,不能使用多态
常用方法：
-
public void addFirst(E e):将指定元素插入此列表的开头
-
public void addLast(E e):将指定元素添加到此列表的结尾。
-
public void push(E e):将元素推入此列表所表示的堆栈。
-
public E getFirst():返回此列表的第一个元素。
-
public E getlast():返回此列表的最后一个元素。
-
public E removeFirst():移除并返回此列表的第一个元素。
-
public E removelast():移除并返回此列表的最后一个元素。
-
public E pop():从此列表所表示的推戈处弹出一个元素。
-
public boolean isEmpty( ):如果列表不包含元素，则返回true。
public static void main(String[]args){
//调用一下方法
showe1();
showe2();
showe3();
}
addFirst、addLast、push方法：
/*
public void addFirst(E e):将指定元素插入此列表的开头。
- public void addLast(E e):将指定元素添加到此列表的结尾。
- public void push(E e):将元素推入此列表所表示的推栈。此方法等效于oddFirst(E)
*/
private static void showe1(){
//创建LinkedList集合对象
LinkedList<string> linked = new LinkedList<>();//使用add方法往集合中添加元素
linked.add( "a" ) ;
linked.add("b");linked .add("c");
system.out.println( linked);//[a, b, c]
// public void addFirst(E e):将指定元素插入此列表的开头。
//Linked .addFirst( "www"" );
linked.push( e: "www" );//此方法等价于addFirst方法（）
System.out.println( linked);//[ www，a， b，c]
// public void addlast(E e):将指定元素添加到此列表的结尾。此方法等效于add()方法
linked.addLast( e: "com");
System.out.println( linked);
}
getFirst()、getLast()方法
/*
public E getFirst():返回此列表的第一个元素。
public E getLast():返回此列表的最后一个元素。
*/
private static void showe2(){
//创建LinkedList集合对象
LinkedList<String> linked = new LinkedList<>();//使用add方法往集合中添加元素
linked .add("a");
linked .add("b");
linked .add("c");
//linked.clear();//清空集合中的元素在获取集合中的元素会抛出NoSuchELementExceptionl
//所以下面增加一个if判断
//public boolean isEmpty():如果列表不包含元素，则返回true
if(!linked.isEmpty){
String first = linked.getFirst();
System.out.println(frist);
String last = linked.getLast();
System.out.println(last);
}
removeFirst()、removeLast()、pop()方法
/*
- public E removeFirst():移除并返回此列表的第一个元素。
- public E removeLast():移除并返回此列表的最后一个元素。
- public E pop():从此列表所表示的堆栈处弹出一个元素。此方法相当于removeFirst
- */
private static void showe3(){
//创建Linkedlist集合对象
LinkedList<String> linked = new LinkedList<>();//使用add方法往集合中添加元素
linked.add("a");
linked.add("b");
linked .add("c" );
System.out.println(linked);
//String first = linked .removeFirst();
string first = linked.pop(); //pop（）等价于removeFirst()方法
system. out.println("被移除的第一个元素:"+first);
string last = linked.removeLast();
System.out.println(“被移除的最后一个元素: "+last);
system.out.println( linked);//[b]
三、HashSet集合介绍
java.util.set接口extends collection接口set接口的特点:
- 1.不允许存储重复的元素
- 2.没有索引,没有带索引的方法,也不能使用普通的for循环遍历
- java.util.HashSet集合implements set接口
HashSet特点:
- 1.不允许存储重复的元素
- 2.没有索引,没有带索引的方法,也不能使用普通的for循环遍历
- 3.是一个无序的集合,存储元素和取出元素的顺序有可能不一致
- 4.底层是一个哈希表结构(查询的速度非常的快)
public static void main( string[]args) {
//set集合不允许存储重复的元素
set<Integer> set = new Hashset<>();
//使用add方法往集合中添加元素
set.add(1);
set.add(3);
set.add(2);
set.add(1);
//使用迭代器遍历set集合
Iterator<Integer> it = set.itefator;while (it.hasNext())i
无识别结果
Integer n = it.next( );
system.out.println(n); //1,2,3
}
//使用增强for遍历set集合
System.out.print1n("---------");
for (Integer i : set) {
System.out.printin(i);
}
HashSet_哈希值
- 哈希值:是一个十进制的整数,由系统随机给出(就是对象的地址值,是一个逻辑地址,是模拟出来得到地址,不是数据实际存储的物理地址)在object类有一个方法,可以获取对象的哈希值
- int hashcode()返回该对象的哈希码值。
hashcode方法的源码:
public native int hashcode();
native:代表该方法调用的是本地操作系统的方法
public static void main(string[]args){
// Person类继承了object类,所以可以使用object类的hashcode方法
Person p1 = new Person();
int h1 = p1.hashcode();
System.out.println(h1);T1967205423/1
Person p2 = new Person();
int h2 = p2.hashcode();
System.out.println(h2) ; //42121758l1
/*
tostring方法的源码;
return getclass ( ).getName() + “@" + Integer.toHexString(hashcode());
*/
system.out.println(p1 ); // com.zhang.hashcode.Person@75412c2f
system.out.println(p2);//com.zhang.hashCode.Person@282ba1e
System.out.println(p1==p2);//lfalse
HashSet集合存储数据的结构
Set集合不允许存储重复元素的原理
public static void main(String[]args) {
//创建Hashset集合对象
Hashset<string> set = new Hashset<>();
string s1 = new String( original: "abc");
string s2 = new String( original: "abc");
set.add(s1);
set.add(s2);
set.add("重地");
set.add(“通话");
set.add( "abc" );
system.out.println(set);//[重地，通话,abc]
}
原理如下：
HashSet存储自定义类型元素
HashSet存储自定义类型元素
- List item
set集合存储元素唯—:
存储的元素(String,Integer , . . .Student , Person… . ),必须重写hashcode方法和equals方法
要求:
*同名同年龄的人,视为同一个人,只能存储一次，*那就必须重写hashcod方法和equals方法
LinkedHashset集合
- java.util.LinkedHashset集合extends Hashset集合linkedHashset集合
特点:
- 底层是一个哈希表(数组+链表/红黑树)+链表:多了一条链表(记录元素的存储顺序),保证元素有序
public static void main(String[]args) {
Hashset<string> set = new Hashset<>();
set.add ( "www" );
set.add("abc");
set.add("abc");
set.add( "zhang");
system.out.printin(set);// [abc，wwv，zhang]无序,不允许重复
LinkedHashSet<String> linked = new LinkedHashSet<>();
linked.add( " www" ) ;
linked.add( "abc");
linked.add("abc") ;
linked.add( "zhang" );
system.out.println(linked) ; // [www，abc，zhang]有序,不允许重复
四、可变参数
可变参数的使用前提:
- 当方法的参数列表数据类型已经确定,但是参数的个数不确定,就可以使用可变参数.
使用格式:
定义方法时使用
修饰符返回值类型方法名(数据类型...变量名)
可变参数的原理:
- 可变参数底层就是一个数组,根据传递参数个数不同,会创建不同长度的数组,来存储这些参数传递的参数个数,可以是o个(不传递),1,2…多个
/*
定义计算(0-n)整数和的方法:
已知:计算整数的和,数据类型已经确定int
但是参数的个数不确定,不知道要计算几个整数的和,就可以使用可变参数add();就会创建一个长度为的数组,new int[ej
add(10);就会创建一个长度为1的数组,存储传递来过的参数new int[]{10};
add(10,20);就会创建一个长度为2的数组,存储传递来过的参数new int[]{10,20};
add(10,20 ,30 ,40 ,50 ,60,70,80 ,90,100);就会创建一个长度为10的数组,存储传递米过的参数、new int[ 10,20 ,30 ,40 ,50 ,60,70,80 ,90,100]
*/
public static void main(String[] args){
int i = add(10,20);
System.out.println(i); //输出结果为30
}
public static int add(int...arr){
// system.out.println(arr);
//lSystem.out.println( arr.length);
I
//定义一个初始化的变量,记录累加求和
int sum = 0;
//遍历数组,获取数组中的每一个元素
for (int i : arr) {
//累加求和
sum += i;
}
//把求和结果返回
return sun;
}
五、collections集合
- java.utils.collections是集合工具类，用来对集合进行操作。
部分方法如下:
- public static boolean addAll(collection c, T… elements):往集合中添加一些元素。
- public static void shuffle(list<?> list)打乱顺序:打乱集合顺序。
public static void main(String[]args) {
ArrayList<string> list = new ArrayList<>();
//往集合中添加多个元素
/*List.add( ""a" );
list.add("b"");
list.add( ""c");
list.add( "d"" );
list.add("e");*/
//public static <T> boolean addAll(Collection<T> c,T... elements):往集合中添加一些元素。collections.addAll(list，...elements: "a", "b","c","d" , "e");
system.out.println(list);//l[a, b,c, d,e]
// public static void shuffLe(List<?> list）打乱顺序:打乱集合顺序。
collections.shuffle(list):
system.out.print1n(list);//[b,*d, c, a, e]
- java.utils.collections是集合工具类，用来对集合进行操作。
- 方法如下:
public static void sort(List list):将集合中元素按照黑认规则排序。
public static void main(string[] args) {
ArrayList<Integer> liste1 = new ArrayList<>();
liste1.add(1);
liste1.add(3);
liste1.add(2);
System.out.println( liste1);//[1，3，2]
// public static <T> void sort(List<T> list):将集合中元素按照默认规则排序。
collections.sort(liste1);//默认是升序
System.out.println(liste1);//[1，2，3]
}
-
java.utils.collections是集合工具类，用来对集合进行操作。
-
方法如下:
public static void sort(List list):将集合中元素按照默认规则排序。
注意:
sort(list list)使用的前提
被排序的集合里边存储的元素,必须实现Comparable,重写接口中的方法compareTo定义排序的规则comparable接口的排序规则:
自己(this)-参数:升序 -
public static void sort(List list,Comparator<? super T〉 ):将集合中元素按照指定规则排序。
-
comparator和comparable的区别
comparable:自己(this)和别人(参数)比较,自己需要实现comparable接口,重写比较的规则compareTo方法
Comparator :相当于找—个第三方的裁判,比较两个
public static void main(String[]args) {
ArrayList<Integer> liste1 = new ArrayList<>();
liste1.add(1);
liste1.add(3);
liste1.add(2);
system.out.println(list01);//[1，3，2]
collections.sort( liste1,new Comparator<Integer>(){
//重写比较的规则
@override
public int compare( Integer o1，Integer o2){
return o1-o2;//升序
//return o2-o1;//降序
});
system.out.println( liste1);//[1，2，3]
}
注意：collection集合是单列集合，而Map集合是双列集合
六、Map集合
java.utiL. Map<k, v>集合Map集合的特点∶
- 1.Map集合是一个双列集合,一个元素包含两个值(一个key,一个value)
- 2.Map集合中的元素, key和value的数据类型可以相同,也可以不同
- 3.Map集合中的元素,key是不允许重复的, value是可以重复的
- 4 . Map集合中的元素,key和value是——对应
java.util.HashMap<k, v>集合implements Map<k, v>接口
Hash/Map集合的特点:
-
1.HashNap集合底层是哈希表:查询的速度特别的快
JDK1.8之前:数组+单向链表
JDK1.8之后:数组+单向链表/红黑树(链表的长度超过8):提高查询的速度 -
2.hashNap集合是一个无序的集合,存储元素和取出元素的顺序有可能不一致java.util.LinkedHashMap<k , v>集合extends HashMap<k , v>集合
-
linkedHashMap的特点:
- 1.LinkedHashMap集合底层是哈希表+链表(保证迭代的顺序)
-
2.LinkedHashMap集合是一个有序的集合,存储元素和取出元素的顺序是一致的
Map接口中定义了很多方法，常用的如下:
- public v put(K key,v value):把指定的键与指定的值添加到Map集合中。
- public V remove(object key):把指定的键所对应的键值对元素在Map集合中删除，返回被删除元素的值。
- public v get(0bject key)根据指定的键，在Map集合中获取对应的值。
- boolean containsKey(0bject key)判断集合中是否包含指定的键。
- public Set keySet():获取Map集合中所有的键，存储到Set集合中。
- public Set<Map.Entry<K,v>> entrySet():获取到Map集合中所有的键值对对象的集合(Set集合)。
put(K key , v value)方法
public static void main(String[] args) {
showe1();
showe2();
showe3();
/* public v put(K key , v value) :
加到Aap集合中。
返回值:v
无识别结果
存储键值对的时候, key不重复
存储键值对的时候, key重复,会使用新的value替换map中重复的vatlue,返回被替换的vaLue值*/
}
private static void showe1() {
//创建Map集合对象,多态
Map<String,string>map = new HashMap<>();
String v1 = map.put(”冷风“，”龙小云“）
System.out.println("v1:"+v1); //v1:null
String v2 = map.put(”冷风“，”龙小云2“）
System.out.println("v2:"+v2);//v2:龙小云
System.out.println("map:"+map);//{冷风=龙小云2}
remove(Object key)方法
/*
public V remove(Object key):把指定的键所对应的键值对元素在Nap集合中删除，返回被删除余元素的值。
返回值:V
key存在, v返回被册除的值
key不存在, v返回null
*/
private static void show02() {
//创建Nap集合对象
Map<String , Integer> map = new HashMap<>();
map.put("赵丽颖" ,168);
map.put("杨颖",165);
map.put(“林志玲"",178);
System.out.println( map);//{林志玲=178，赵丽颖=168，杨颖=165}
Integer v1 = map.remove( key:"林志玲"");
System.out.println("v1 : "+v1);//v1:178
system.out.println(map);//{赵丽颖=168，杨颖=165}
get(0bject key）方法：
/*
public v get(0bject key）根据指定的键，在Nap集合中获取对应的值。
返回值:.
key存在,返回对应的value值
key不存在,返回null
*/
private static void showe3() {
//创建Map集合对象
Map<String , Integer> map = new HashMap<>( );
map.put("赵丽颖",168);
map.put("杨颖",165);
map.put(“林志玲",178);
Integer v1 = map.get(杨颖");
system.out.print1n( "v1 : "+v1);//v1:165
Integer v2 = map.get("迪丽热巴");
system.out.println("v2 : "+v2);//v2:null
}
扫一扫
3994
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
