java基础之数据和集合（六）

最新推荐文章于 2023-01-26 16:09:34 发布

每天至少八杯水i

最新推荐文章于 2023-01-26 16:09:34 发布

阅读量755

点赞数

分类专栏： Java基础回顾文章标签： java

本文链接：https://blog.csdn.net/weixin_43536495/article/details/123653528

版权

Java基础回顾专栏收录该内容

7 篇文章 0 订阅

订阅专栏

Java数组

定义数组的语法:

数据类型 [] 数组名 = new  数据类型[数组长度];

也可以:

数据类型 数组名[]  = new  数据类型[数组长度];

如, 定义一个可以存储5个int类型数据的数组:
//可以在创建数组的时候给初始值，元素个数为数组length
int [] mydata = new int[]{3,6,9,8};

int [] data = new int[5];

数组扩容：

//Arrays工具类copyOf(源数组, 新数组的长度) 可以实现数组的扩容
date = Arrays.copyOf(data, data.length*3/2);

二位数组：

int[][] mydata = new int[5][];


   格式1: 动态初始化
数据类型 数组名 [ ][ ] = new 数据类型[m][n]
数据类型 [ ][ ]  数组名 = new 数据类型[m][n]
数据类型 [ ]   数组名 [ ] = new 数据类型[m][n]

举例：int [ ][ ]  arr=new  int [5][3];  也可以理解为“5行3例”

格式2: 静态初始化
数据类型 [ ][ ]   数组名 = {{元素1,元素2....},{元素1,元素2....},{元素1,元素2....}.....};

在这里插入图片描述

数组的一维和二维；

package com.hao.se;
import java.util.Arrays;

/*
 *@hao
 *
 *
 *
 */
public class Araa {
    public static void main(String[] args) {
        int j=10;
        int []a1=new int[9];
        int [][]a2=new int[3][3];
        //一维数组
        //存值
        for (int i=0;i<9;i++){
            a1[i]=j;
            j++;
            System.out.print(a1[i]+"  ");
        }
        System.out.println();
        //增强for循环来取值
        for (int i:a1) {

            System.out.print(i+"  ");
        }
        System.out.println();
        System.out.println("------二维数组------");
        //二位数组
        a2[1][0]=1;a2[1][1]=2;a2[1][2]=3;
        a2[0][0]=4;a2[0][1]=5;a2[0][2]=6;
        for (int i=0;i<a2.length-1;i++){

          for (int q=0;a2[i]!=null&&q<a2.length;q++) {
              System.out.println("a2"+"["+i+"]"+"["+q+"]"+"的值为"+a2[i][q]);
          }
        }
    }
}

数组常用方法：

static int：

binarySearch(int[] a, int key)

在a数组中查找key元素是否存在,如果存在返回key元素在数组中的索引值,如果不存在返回负数。
static int[]：

copyOf(int[] original, int newLength)

数组的复制, newLength指定新数组的长度, 把orginal数组中的元素复制到新的数组中,返回新的数组。
static int[]：

copyOfRange(int[] original, int from, int to)

把original数组[from,to]范围的元素复制到新的数组中, 返回新的数组。
static String：

deepToString(Object[] a)

把多维数组中的元素转换为字符串。
static void：

fill(int[] a, int val)

使用val值填充整个a数组。
static void：

parallelSort(int[] a)

对数组a进行并行排序, 适合数组元素非常多的情况。
static void：

sort(int[] a)

对数组a进行排序。
static void：

sort(T[] a, Comparator<? super T> c)

对对象数组排序,可以指定对象的比较器。
static String：

toString(int[] a)

把数组的元素转换为字符串

public static void main(String[] args) {
		int [] data = {67,23,786,4,12,87};
		
		//1)对数组排序
		Arrays.sort(data);
		//2)打印数组
		System.out.println( Arrays.toString(data)); //[4, 12, 23, 67, 87, 786]
		//3)数组复制
		data = Arrays.copyOf(data, data.length*2 );
		System.out.println( Arrays.toString(data )); //[4, 12, 23, 67, 87, 786, 0, 0, 0, 0, 0, 0]
		data = Arrays.copyOf(data, data.length*2/3 );
		System.out.println( Arrays.toString(data));  //[4, 12, 23, 67, 87, 786, 0, 0]
		//4)填充
		Arrays.fill(data, 6, data.length, 666);
		System.out.println( Arrays.toString(data));  //[4, 12, 23, 67, 87, 786, 666, 666]
		//5)二分查找, 前提是数组已经由小到大排序
		Arrays.sort(data);
		System.out.println( Arrays.toString(data));  //[4, 12, 23, 67, 87, 666, 666, 786]
		//只要是返回结果大于等于0,表示元素存在, 结果是负数表示不存在
		System.out.println( Arrays.binarySearch(data, 4));
		System.out.println( Arrays.binarySearch(data, 67));
		System.out.println( Arrays.binarySearch(data, 786));
		System.out.println( Arrays.binarySearch(data, 666));
		System.out.println( Arrays.binarySearch(data, 888));  //-9
		
	}

冒泡排序

在这里插入图片描述

代码实现：

public static void main(String[] args) {
		int [] data = {56,23,89,5,99,32};
		System.out.println( Arrays.toString(data));
		System.out.println("------------------------------");
		
		for( int x = 0 ; x < data.length - 1; x++){
			//第x轮, 把第x大的交换到最后
			for(int i = 0 ; i < data.length-1 - x ; i++){
				if ( data[i] > data[i+1] ) {
					int t = data[i];
					data[i] = data[i+1];
					data[i+1] = t;						
				}
				System.out.println( Arrays.toString(data));
			}
			System.out.println("------------------------------");
		}
		
	}

一轮一轮的比较把最大的放到最后面，直到从小到大排序好；

选择排序

在这里插入图片描述

![20210807160119](E:\back to square one\JavaSe\IMG\20210807160119.png)public static void main(String[] args) {
		int [] data = {56,23,89,5,99,32};
		System.out.println( Arrays.toString(data));
		System.out.println("------------------------------");
		
		for(int x = 0 ; x < data.length-1 ; x++){
			//1) 选择最小的,交换到x位置
			int min = x ; 		//保存最小元素的下标,假设x元素最小
			//找当前最小元素的下标
			for( int i = x+1 ;  i< data.length; i++){
				if (data[i] < data[min]) {
					min = i;
				}
			}
			//把当前最小元素交换到x位置
			if ( min != x ) {
				int t = data[x]	;
				data[x] = data[min];
				data[min] = t;
			}
			System.out.println( Arrays.toString(data));
		}
			
	}

二分查找法

在这里插入图片描述

public static void main(String[] args) {
		int [] data = {5, 23, 32, 56, 89, 99};
		
		System.out.println( binarySearch(data, 5));
		System.out.println( binarySearch(data, 99));
		System.out.println( binarySearch(data, 23));
		System.out.println( binarySearch(data, 66));
		System.out.println( binarySearch(data, -88));
	}

	//定义方法, 实现二分查找
	//如果myarray数组中存在key元素,返回key元素在数组中的索引值, 如果不存在key元素返回-1
	public static int binarySearch(int [] myarray, int key) {
		int from = 0 ;
		int end = myarray.length-1;
		int mid = (from + end) /2;
		
		while( from <= end ){
			if ( myarray[mid] == key ) {
				return mid;
			}else if ( myarray[mid] < key) {  	//查找的元素比中间的数大, 在右一半
				from = mid + 1 ;
				mid = (from + end) /2;
			}else {								//查找的元素比中间的数小, 在左一半
				end = mid - 1;
				mid = (from + end) /2;
			}
		}
		
		return -1;
	}

Java集合框架

集合分为两大类:

● Collection集合: 存储数据时是单个存储的

● Map集合：存储数据时是按<键,值>对的形式一对一对存储的

在这里插入图片描述

Java中Collection的基本操作

boolean：add(E e) 向集合中添加元素e

boolean：addAll(Collection c) 把集合c中所有元素都添加到当前集合中

void：clear() 清空当前集合中所有的元素

boolean：contains(Object o) 在当前集合中判断是否包含元素o

boolean：containsAll(Collection c) 判断当前集合是否包含集合c中的所有元素

boolean：equals(Object o)

int：hashCode()

boolean：isEmpty() 判断集合是否为空

Iterator：iterator() 返回当前集合的迭代器

boolean：remove(Object o) 从当前集合中删除第一个与o匹配的元素

boolean：removeAll(Collection c) 在当前集合中删除在c集合中出现的所有元素

int：size() 返回集合中元素的个数

Object[]：toArray() 把集合转换为数组

T[]：toArray(T[] a)

List集合

List集合的特点：存储的元素是***有序/可重复的。***

List集合为每个元素指定了一个索引值, 主要增加了针对索引值的操作。

 public static void main(String[] args) {
        //创建一个List集合
        List<String> A = new ArrayList<>();
        List<String> B = new ArrayList<>();
//        add(int index, E element) 在当前集合的index位置插入元素element
            A.add("我");
            A.add("爱");
            A.add("你");
            A.add("宝");
            A.add("宝");
//        addAll(int index, Collection<? extends E> c) 把集合c中的所有元素插到当前集合的index位置
        A.add(3,"bao");
        B.addAll(A);
        System.out.println(A);
        System.out.println("B"+B);
//        get(int index) 返回index位置的元素
       String C=A.get(2);
        System.out.println(C);
//        indexOf(Object o) 返回元素o在集合中第一次出现的位置
          int D=A.indexOf("宝");
        System.out.println(D);
//        lastIndexOf(Object o) 返回元素o在集合中最后一次出现的位置
        int E=A.lastIndexOf("宝");
        System.out.println(E);
//        listIterator() 返回List迭代器
        System.out.println(A.listIterator());//java.util.ArrayList$ListItr@1b6d3586
//        remove(int index) 删除指定位置的元素  默认删除第一个
        A.remove("宝");
        System.out.println(A);
//        set(int index, E element) 修改指定位置的元素
        A.set(1,"不");
        System.out.println(A);
//        sort(Comparator<? super E> c) 排序

//        subList(int fromIndex, int toIndex) 返回[frominde, toIndex)范围内的子列表
        List<String> F=A.subList(2,5);
        System.out.println(F);
    }

Java中ArrayList与Vector

ArrayList与Vector底层都是数组, 访问快, 添加/删除慢

● ArrayList与Vector底层都是数组

● ArrayList与Vector默认初始化容量:10

● ArrayList扩容: 1.5倍, Vector扩容:2倍

● Vector提供的方法都使用了synchronized修饰 ,是线程安全的，ArrayList不是线程安全的。

LinkedList

LinkedList底层是双向链表

单向链表

在这里插入图片描述

双向链表

在这里插入图片描述

主要方法：

void：addFirst(E e) 添加到善

void：addLast(E e) 添加到尾部

E：element()返回第一个元素

E：getFirst() 返回第一个元素

E：getLast()返回最后一个元素

boolean：offer(E e) 把元素添加到尾部

boolean：offerFirst(E e) 添加到状况

boolean：offerLast(E e) 添加到尾部

E：peek() 返回第一个元素

E：peekFirst() 返回第一个元素

E：peekLast() 返回最后一个元素

E：poll() 删除第一个元素并返回

E：pollFirst() 删除第一个元素并返回

E：pollLast() 删除最后一个元素并返回

E：pop()删除第一个元素并返回

void：push(E e) 在头部添加元素
    
E：removeFirst() 删除第一个元素并返回

E：removeLast() 删除最后一个元素并返回

经常使用push( E ) / pop() 模拟栈, 栈的特点是先进后出/后进先出.   push( E )把元素添加到链表的头部,  pop()把链表头部的元素删除并返回。

使用offer( E ) / poll()  模拟队列,  队列的特点是先进先出, offer( E )添加元素是在链表的尾部添加,  poll() 是把链表的头部元素删除并返回。

Set

Set集合特点: 存储的数据无序,不可重复

HashSet

	public static void main(String[] args) {
		//1)创建Set集合
		Set<String> set = new HashSet<>();
		
		//2)添加元素
		set.add("666");
		set.add("wkcto");
		set.add("hehehe");
		set.add("abc");
		
		//3)直接打印, 输出的顺序可能与添加的顺序不一致 
		System.out.println( set );   	//[abc, wkcto, 666, hehehe]
		
		//4)添加重复的元素
		set.add("wkcto");
		set.add("666");
		//Set集合中不能存储重复的元素		
		System.out.println( set ); 		//[abc, wkcto, 666, hehehe]
		
		//5)删除
		set.remove("abc");
		System.out.println( set); 		//[wkcto, 666, hehehe]
		
		//6)迭代
		Iterator<String> iterator = set.iterator();
		while (iterator.hasNext()) {
			String string = (String) iterator.next();
			System.out.print( string + "\t");
		}
		System.out.println();
		
	}

HashSet集合特点

● HashSet底层是HashMap

● 向Hashset中添加元素, 实际上是把这个元素作为键添加到底层的HashMap中

● HashSet实际上就是底层HashMap的键的集合

TreeSet

TreeSet集合实现了SortedSet接口, 可以对集合中元素进行自然排序, 要求集合中的元素必须是可比较的。

public static void main(String[] args) {
		//1) 创建TreeSet集合,存储Person对象, 在构造方法中指定Comparator比较器,按姓名升序排序
		TreeSet<Person> treeSet = new TreeSet<>(new Comparator<Person>() {
			//在匿名内部类中重写接口的抽象方法
			@Override
			public int compare(Person o1, Person o2) {
				//指定一个比较规则
				return o1.name.compareTo(o2.name);   //姓名升序
			}
		});
		
		//2)添加元素
		treeSet.add(new Person("lisi", 18));
		treeSet.add(new Person("feifei", 28));
		treeSet.add(new Person("yong", 35));
		treeSet.add(new Person("bin", 36));
		treeSet.add(new Person("zhang", 33));
		
		//3)直接打印
		System.out.println( treeSet );
		
		//4) 根据已有TreeSet创建新的TreeSet集合
		TreeSet<Person> treeSet22 = new TreeSet<>(treeSet);
		System.out.println( treeSet22 );
		
		//5) 使用TreeSet的无参构造, 没有指定Comparator比较器, 要求Person类实现Comparable接口
		TreeSet<Person> treeSet33 = new TreeSet<>();
		treeSet33.addAll(treeSet);		
		System.out.println( treeSet33);
	}

TreeSet集合底层是TreeMap，向TreeSet集合添加元素,实际上是把该元素作为键添加到了底层TreeMap中，TreeSet集合实际上就是底层TreeMap的键的集合。

Collection集合小结

Collection集合

只能存储引用类型的数据, 单个存储

基本操作: add(), remove(), contains(), size(), iterator()

List集合

特点: 存储的元素是有序,可重复的

为每个元素指定一个索引值

增加的方法, 针对索引值的操作, listIterator(), subList(), sort(Comparator)

ArrayList集合

底层是数组, 访问快, 添加/删除效率低

初始化容量: 10, 扩容: 1.5倍

Vector集合

底层是数组, 它是线程安全的, ArrayList不是线程安全的

初始化容量: 10, 扩容: 2倍

LinkedList集合

底层是双向链表, 添加/删除效率高, 访问慢

List集合应用场景

ArrayList适用于以访问为主, 很少添加/删除的情况

LinkedList适用于经常添加/删除的情况

Set集合

特点: 数据无序,不可重复

HashSet集合

底层是HashMap, HashSet实际上就是HashMap键的集合

TreeSet集合

底层是TreeMap, TreeSet实际上就是TreeMap键的集合

TreeSet实现了SortedSet接口, 可以对元素自然排序, 要求元素必须是可比较的：

● 在构造方法中指定Comparator比较器对象

● 如果没有Comparator比较器, 集合元素的类必须实现Comparable接口

Set集合的应用场景

如果不需要对Set集合进行排序就选择HashSet

如果需要对Set集合的元素进行排序就选择TreeSet

注意:

List集合/HashSet集合的contains( e ) / remove( e )等方法需要调用对象的equals()方法, 这些集合中的元素的类需要重写equals()方法

TreeSet集合中contains( e )/ remove( e) 等方法判断是否同一个对象是根据Comparator/Comparable的比较结果是否为0来判断的, 如果比较结果为0表示同一个元素

在多线程环境中：

● 如果使用List集合就直接使用java.util.concurrent.CopyOnWriteArrayList类。

● 如果使用Set集合，不需要排序,使用java.util.concurrent.CopyOnWriteArraySet类, 如果需要排序,使用java.util.concurrent.ConcurrentSkipListSet集合。

Map

在这里插入图片描述

void：clear() 清空集合中所有的<键,值>对

boolean：containsKey(Object key) 判断是否包含指定的键

boolean：containsValue(Object value) 判断是否包含指定的值

Set>：entrySet() 返回所有Entry的集合, 一个<键,值>对就是一个Entry

boolean：equals(Object o)

V：get(Object key) 返回键对应的值

boolean：isEmpty() 判断集合是否为空

Set：keySet() 返回键的集合

V：put(K key, V value) 添加对, 如果key键已存在,使用value值替换原来的值

void：putAll(Map m) 把m集合中所有的<键,值>对添加到当前集合中

V：remove(Object key) 只要key匹配就删除对应的<键,值>对

default boolean：remove(Object key, Object value) 删除

default V：replace(K key, V value) 使用value值替换key原来的值

int：size() 返回<键,值>对的数

Collection：values() 返回所有值的集合

案例：

public static void main(String[] args) {
		//1) 创建Map集合, 用来保存<员工姓名,员工工资>
		//Map是一个接口,需要赋值实现类对象
		Map<String, Integer>  map = new HashMap<>();
		
		//2) 添加数据
		map.put("feifei", 30000);
		map.put("bin", 40000);
		map.put("zhang", 50000);
		map.put("yong", 100000);
		
		//3) 直接打印, 存储顺序与添加顺序可能不一致
		System.out.println( map );
		//{bin=40000, yong=100000, zhang=50000, feifei=30000}
		
		//4)添加重复的键, 如果键重复,会使用新的value值替换原来的值, Map中的键不能重复的
		map.put("bin", 40001);
		System.out.println( map );
		
		//5)修改
		map.replace("feifei", 30002); 
		map.replace("yan", 6666);			//替换时, 如果键不存在,替换不成功
		System.out.println( map );
		
		//6)判断
		System.out.println( map.isEmpty() );
		System.out.println( map.size());
		System.out.println( map.containsKey("feifei"));
		System.out.println( map.containsValue(100000));
		System.out.println( map.get("yong"));
		System.out.println( map.get("cui"));  		//如果键不存在, 返回null
		
		//7) 删除
		map.remove("bin", 40000); 		//删除<"bin", 40000>对,  要求键与值都匹配才能删除
		System.out.println( map ); 		//{bin=40001, yong=100000, zhang=50000, feifei=30002}
		map.remove("yong");				//只要键匹配就删除
		System.out.println( map );
		
	}

HashMap底层实现原理

HashMap底层是哈希表(散列表)，哈希就是一个数组，数组的每个元素是一个单向链表。

在这里插入图片描述

● 在第一次执行put方法时,给哈希表的数组(哈希桶)默认初始化,容量: 16

● hashMap加载因子是0.75

● 当hashMap中<键,值>对的数量 > 哈希桶容量 * 加载因子时, 哈希桶(数组)要扩容 , 按2倍大小扩容

● HashMap可以指定初始化容量, 系统会自动调整为2的幂次方, 可以快速的计算数组的下标

● 如果单向链表中结点的个数超过8个时, 系统会自动的把单向链表转换为树形结构

HashTable和HashMap的区别

● 与HashMap一样,底层也是哈希表, 但是HashTable是线程安全的

● HashMap默认初始化容量: 16, HashTable默认初始化容量:11

● 加载因子: 0.75, 当键,值对的数量大于加载因子*哈希桶容量时, 要扩容

● HashMap默认按2倍大小扩容, HashTable默认按 2倍 + 1 大小扩容

● HashMap可以指定初始化容量, 系统会自动调整为2的幂次方, HashTable也能指定初始化容量, 系统不会自动调整

● HashMap中的键与值都可以为null, HashTable中的键与值都不能为null

● HashMap的父类是AbstractMap , HashTable的父类是Dictionary

Java Properties类

Properties继承了HashTable, 它的键与值都是String类型。

经常使用Properties设置/读取系统的属性值

Java Properties类

Properties继承了HashTable, 它的键与值都是String类型。

经常使用Properties设置/读取系统的属性值

在这里插入图片描述

Java Map集合小结

Map集合按<键,值>对的形式存储元素

put( k, v), containsKey( k ), containsValue( v ) , get( k ), remove( k )

keyset() , values(), entrySet()

HashMap

底层是哈希表(散列表), 哈希表就是一个数组, 数组的每个元素是一个单向链表

HashTable

底层是哈希表, 它是线程安全的, HashMap不是线程安全的

初始化容量:11, HashMap初始化容量: 16

加载因子: 0.75, 当<键,值>对的数量大于哈希桶容量 * 加载因子时, 哈希桶扩容

HashTable默认扩容: 2倍 + 1 , HashMap扩容: 2倍

HashTable的键与值都不能为null, HashMap的键与值可以为null

创建HashTable时, 可以指定初始化容量; HashMap会自动把初始化容量调整为2的幂次方,就是为了快速计算数组的下标

Properties

继承了HashTable, 键与值都是String类型

经常用于设置/读取系统属性值

一般情况下, 系统属性会保存在配置文件中, 可以通过Properties读取配置文件的内容, 也可以使用ResouceBundle读取配置文件的属性

TreeMap

实现了SortedMap接口, 可以根据键自然排序, 要求键必须是可比较的

要么指定Comparator比较器, 如果没有Comparator比较器,键需要实现Comparable接口

Comparator比较与Comparable如何选择?

对于TreeMap来说, 先根据Comaparator比较器进行比较大小 , 如果没有Comparator比较器, 再选择Comparable接口。

对于开发人员来说, 一般通过实现Comparable接口定义一个默认的比较规则 , 通过Comparator比较器定义若干不能同的排序规则。

如何选择Map?

如果不需要根据键排序就选择HashMap, 如果需要根据键排序就选择TreeMap。

如果在多线程程序中, 使用java.util.concurrent包中的类,如果不需要根据键排序选择ConcurrentHashMap, 如果需要根据键排序选择ConcurrentSkipListMap

</图片来自于百度/>

每天至少八杯水i

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
java基础之数据和集合（六）

Java数组定义数组的语法:数据类型 [] 数组名 = new 数据类型[数组长度];也可以:数据类型数组名[] = new 数据类型[数组长度];如, 定义一个可以存储5个int类型数据的数组://可以在创建数组的时候给初始值，元素个数为数组lengthint [] mydata = new int[]{3,6,9,8};int [] data = new int[5];数组扩容：//Arrays工具类copyOf(源数组, 新数组的长度) 可以实现数组的扩容da
复制链接

扫一扫