二维数组和容器的基本知识

二维数组

二维数组

数组中嵌套数组,数组中还是数组

定义、声明

数据类型 变量名;
 		数据类型[] 数组名;  ---一维数组的声明
  		数据类型[][] 数组名;	---二维数组
  		数据类型[] 数组名[];
  		数据类型 数组名[][];

初始化

动态初始化: 创建数组对象的时候不赋值,后续赋值
   		数据类型[][] 数组名 = new 数据类型[一维的长度][二维的长度];
   		一维的长度:外层数组
   		二维的长度:内层的每一个小数组
   		数据类型[][] 数组名 = new 数据类型[一维的长度][];
   			数组名[0] = 内层数组的创建方式(不可以使用简略写法);
   		
静态初始化:创建数组对象的同时不赋值
   		数据类型[][] 数组名 = new 数据类型[][]{{1,2,3},{2,3},{4}...};

遍历

一维数组的遍历方式:

  • 普通for–>遍历的数组的索引
  • for…each->增强for->i作为数组中的每一个数据值
  • 二维数组的遍历:
  • 循环嵌套
import java.util.Arrays;

public class DimensionalTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[][] arr=new int[3][2];
		for(int i=0;i<arr.length;i++) {
			for(int j=0;j<arr[i].length;j++) {
				arr[i][j]=i;
			}
		}
		System.out.println(Arrays.deepToString(arr));
		String [][]arr1=new String[3][];
		arr1[0]=new String[3];
		arr1[1]=new String[2];
		arr1[2]=new String[1];
		arr1[0][0]="你";
		arr1[0][1]="好";
		arr1[0][2]="呀";
		
		arr1[1][0]="中国";
		arr1[1][1]="真好";
		
		arr1[2][0]="我爱你中国";
		
		System.out.println(Arrays.deepToString(arr1));
		
		for(String[] a:arr1) {
			for(String b:a) {
				System.out.print(b);
			}
		}
		
		arr1[0]=new String[] {"你","好","呀"};
		arr1[1]=new String[] {"中国","真好"};
		arr1[2]=new String[] {"我爱你中国"};
		for(int i=0;i<arr1.length;i++) {
			for(int j=0;j<arr1[i].length;j++) {
				System.out.println(arr1[i][j]);
			}
		}
	}

}

容器

Collection

接口 容器类的父接口

​ List 有序可重复

​ Set 无序不可重复

ArrayList

​ 底层是有数组实现,通过数据拷贝实现

  • 根据索引进行查询效率高
  • 进行增删效率低
  • 适合大量的做查询,不适合大量做增删
  • 扩容:每次扩容原容量的1.5倍(newCapacity = oldCapacity + (oldCapacity >> 1)😉,使用 Arrays.copyOf进行数据的拷贝

ArrayList() 内部空数组,第一次添加数据时构建10个大小

ArrayList(int initialCapacity) 创建指定大小的容器,当能够确定数据多少的时候,推荐使用,效率更高

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.ListIterator;
import java.util.Map;
import java.util.Set;



public class ArrayListTest02 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ArrayList<Student> list=new ArrayList();
		
		
		Student student=new Student();
		student.setName("zs");
		student.setClassgrade("207A");
		student.setAge(18);
		
		
		Student student1=new Student();
		student1.setName("ls");
		student1.setClassgrade("207A");
		student1.setAge(17);
		//添加
		list.add(student);
		list.add(student1);
		//修改
			list.set(0, student).setClassgrade("208A");
			System.out.println(list);
		for (int i = 0; i < list.size(); i++) {
			list.get(i).setClassgrade("206A");
		}
		//删除
//		list.remove(0);
		System.out.println(list);
		//拿到不同的年龄
		ListIterator<Student> lt=list.listIterator();
		Set<Integer> set=new HashSet();
		while(lt.hasNext()) {
			
			Student a=lt.next();
			set.add(a.getAge());
			
		}
		
		System.out.println(set);
		
		
		
		Map<Integer,String> map=new HashMap();
		//存值
		map.put(1, "小明");
		map.put(2, "小红");
		map.put(3, "小白");
		
		System.out.println(map);
		//查找key值是否存在
		System.out.println(map.containsKey(1));
		//查找value值是否存在
		System.out.println(map.containsValue("小红"));
		
		//打印修改前的值
		System.out.println(map.put(3, "小兰"));
		System.out.println(map);
		//遍历的三种方式
		System.out.println("--------keySet()-------");
		Set<Integer> set1=map.keySet();
		System.out.println(set1);
		for (Integer i : set1) {
			System.out.println(map.get(i));
		}
		
		System.out.println("--------values()--------");
		Collection<String> co=map.values();
		Iterator it= co.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
		
		System.out.println("--------entrySet()--------");
		Set<Map.Entry<Integer, String>> set2=map.entrySet();
		System.out.println(set2);
		Iterator<Map.Entry<Integer, String>> it2=set2.iterator();
		while(it2.hasNext()) {
			Map.Entry<Integer, String> entry=it2.next();
			System.out.println(entry.getKey()+"------------"+entry.getValue());
		}
	}

}
class Student{
	private String name;
	private int age;
	private String classgrade;
	
	public Student() {
		
	}

	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;
	}

	public String getClassgrade() {
		return classgrade;
	}

	public void setClassgrade(String classgrade) {
		this.classgrade = classgrade;
	}

	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + ", classgrade=" + classgrade + "]";
	}
	
	
	
}

Vector

向量

​ 与ArrayList像,都是由数组实现内部存储结构

区别:

早起jdk版本提供,后续jdk版本推荐ArrayList代替Vector;Vector线程安全,效率较低,ArrayList线程不安全,效率较高,重效率轻安全

扩容:每次扩容原容量的2倍,没有ArrayList节省空间

LinkedList

LinkedList是一种可以在任何位置进行高效地插入和删除操作的有序序列。

底层:双向链表实现

优点:增删效率高

缺点:查询效率低

set

Set 接口中的元素无序不可重复:不包含重复元素,最多包含一个null,元素没有顺序 。

Set接口: 无序不可重复

  • List接口: 有序就可重复
  • 都是Collection的子接口,都是存储单个数据值的容器
  • 无序: 存储的顺序和内部真实存放的顺序不同
  • 实现类: HashSet …
public class SetDemo01 {
	public static void main(String[] args) {
		Set set=new HashSet();
		set.add("haha");
		set.add("abc");
		set.add("cd");
		set.add("a");
		set.add("hehe");
		set.add("hehe");
		set.add("hehe");
		System.out.println(set);
	}
}

注意

容器中只能存放引用数据类型的数据 int->3

  •  会发生自动拆装箱,不需要我们手动控制
    
  •  为所有的基本数据类型提供了对应的包装类型
    
  •  int->Integer
    
  •  byte->Byte
    
  •  short->Short
    
  •  long->Long
    
  •  double->Double
    
  •  float->Float
    
  •  char->Character
    
  •  boolean->Boolean
    

Map

容器接口

  • 存储的每一个数据都是k-v组成
  • k 无序的,不可重复–>Set集合
  • v 无序的,可重复 -->Collection集合
  • key和value之间存在映射关系,根据key获取value
  • 一个key,只能对应一个value,如果想要对应多个,可以把value存在容器中
  • 如果存储的数据的时候,key相同的数据value会覆盖
  • HashMap
    • 底层 : hash表实现(数组+链表+红黑树)
Map的遍历方式

1.keySet() 获取所有的key,返回一个Set集合,然后可以根据key获取value

		Set<Integer> set=map.keySet();
		System.out.println(set);
		for(Integer i:set){
			System.out.println(map.get(i));;
		}

2.values() 获取所有的value值,返回一个Collection集合

		Collection<String> col=map.values();
		Iterator it=col.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}

3.entrySet() 返回此映射中包含的映射关系的Set集合

		Set<Map.Entry<Integer,String>> set2=map.entrySet();
		System.out.println(set2);
		Iterator<Map.Entry<Integer,String>> it2 = set2.iterator();
		while(it2.hasNext()){
			Map.Entry<Integer,String> entry=it2.next();
			System.out.println(entry.getKey()+"--->"+entry.getValue());
		}

手写简单容器

import java.util.Arrays;

/**
 * 手写容器
 * @author zhuch
 *
 */
public class HandwrittenContainer {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ArrayListTest arr=new ArrayListTest();
		arr.add("123");
		arr.add("1234");
		System.out.println(arr);
	}

}
class ArrayListTest{
	
	private String[] arr;
	private int size;
	
	//删除
	public void remove(int index) {
		if(index<0 || index>=size) {
			throw new ArrayIndexOutOfBoundsException(index+"数组越界");
		}
		//备份原数组
		String[] arr1=arr;
		//arr指向一个长度-1的新数组
		arr=new String[size-1];
		//遍历原数组
		for(int i=0;i<size-1;i++) {
			if(i<index) {
				arr[i]=arr1[i];
			}else {
				if(i==index) {
					continue;//跳出本次循环
				}
				arr[i-1]=arr1[i];
			}
		}
		size--;
	}
	
	//获取数据get 参数索引位置
	public String get(int index) {
		if(index<0 || index>=size) {
			throw new ArrayIndexOutOfBoundsException(index+"数组越界");
		}
		return arr[index];
	}
	
	//添加
	public void add(String value) {
		// 第一个数
		if(arr==null) {
			arr=new String[1];
			arr[0]=value;
			size++;
			return;
		}
		//不是第一个数
		String[] arr1=arr;
		arr=new String [size+1];
		for(int i=0;i<size-1;i++) {
			arr[i]=arr1[i];
		}
		//在最后添加
		arr[size]=value;
		size++;
		
	}
	@Override
	public String toString() {
		return "ArrayListTest [arr=" + Arrays.toString(arr) + ", size=" + size + "]";
	}
	
	//size
	public int size() {
		return this.size;
	}
	
}

发布了5 篇原创文章 · 获赞 5 · 访问量 252
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 1024 设计师: 上身试试

分享到微信朋友圈

×

扫一扫,手机浏览