数组
一、数组（一维 int a [ ] ; 二维 int a[ ][ ] ）
1、含义
- 数组是一个变量，存储相同数据类型的一组数据
- 声明一个变量就是在内存空间划出一块合适的空间
- 声明一个数组就是在内存空间划出一串连续的空间
- 数组长度固定不变，避免数组越界
2、基本要素 int a[]={1,2,3,4,5}
- 标识符 ：数组名称 |a
- 数组元素：数组内容（值） |1,2,3,4,5
- 元素下标：元素所在数组位置，从0开始 |0,1,2,3,4
- 元素类型：int/double/string… |int
3、赋值使用：初始默认值为0
- 类型[] 数组名=new 类型 [长度]；数组名 [长度]=值
- 声明数组：类型[] 数组名
- 分配空间：数组名=new 类型 [长度]
- 赋值：数组名 [长度]=值
- 类型 [ ] 数组名={ 值1，值2，值3… }
- 类型 [ ] 数组名=new 类型 [ ] { 值1，值2，值3… }
//方法一： int []a; a=new int[5]; a[0]=1; //方法二： int []a=new int[5]; a[0]=1; //方法三： int a[]={1,2,3,4,5}; //方法四： int a[]=new int[]{1,2,3,4,5};
4、函数调用
- 获取数组长度 ：数组名.length
- 数组排序 ：Arrays.sort(数组名)
- 将数组转为字符串 ：Arrays.toString(数组名)
5、排序算法
冒泡排序
- 双循环比较，数组两两相邻数值比较，较大的排后（从小到大排序）
int a[]=new int[]{1,2,3,4,5};
for (int i = 0; i <a.length-1 ; i++) {
for (int j = 0; j <a.length-1-i ; j++) {
if(a[j]>a[j+1])
{
int t=a[j];
a[j]=a[j+1];
a[j+1]=t;
}
}
}
System.out.println(Arrays.toString(a));
选择排序
- 选中一个标记值，遍历比较，遇到小于标记值的记录其索引，更换标记索引，一遍遍历获取最小值索引，与标记值互换，重复形成从小到大排序
int a[]=new int[]{1,2,3,4,5};
int index;
for (int i = 0; i <a.length-1 ; i++) {
index=i;
for (int j = i; j <a.length ; j++) {
if(a[j]<a[index])
{
index=j;
}
}
int t=a[i];
a[i]=a[index];
a[index]=t;
}
System.out.println(Arrays.toString(a));
反转排序:前后调换位置
int a[]=new int[]{8,5,9,87,7,12,85,32,112,47,28,4,55,2,56,74,1};
//Arrays.sort(a);
for (int i = 0; i < a.length/2; i++) {
int t=a[i];
a[i]=a[a.length-1-i];
a[a.length-1-i]=t;
}
System.out.println(Arrays.toString(a));
//[1, 74, 56, 2, 55, 4, 28, 47, 112, 32, 85, 12, 7, 87, 9, 5, 8]
6、求最大值、最小值
//求最大值、最小值
int a[] = new int[]{2,8,9,3,6,4,5};
int max=a[0];
int min=a[0];
for (int x:a) { //foreach————遍历数组
if(x<min){
min=x;
}
if(x>max){
max=x;
}
}
System.out.println("最大值为："+max+",最小值为："+min);//最大值为：9,最小值为：2
7、复制数组到另一个数组中
//方法一：循环复制数组
int x[]=new int[a.length+1];
for (int i = 0; i < a.length; i++) {
x[i]=a[i];
}
//方法二：Arrays.copyOf（原数组,长度）；
Arrays.copyOf(a,a.length+1);
二、集合ArrayList、LinkedList、HashSet、HashMap
- List 接口：存储一组 不唯一，有序（插入顺序）的对象
- Set 接口：存储一组 唯一，无序的对象
- Map接口：存储一组 键值对象，提供key到value的映射
1、ArrayList（数组：查找快、增删慢）
- ArrayList实现了长度可变的数组，在内存中分配连续的空间，遍历元素和随机访问元素的效率比较高
- 基本数据类型（8）：byte short int long float double boolean char
- 引用数据类型：String 、Integer、Double等
- 通过List接口 创建 ArrayList 集合
- List<泛型> 指定泛型，只能放入符合泛型类型的数据进入集合中
- List 不指定泛型，类型默认为Object,可添加多种数据类型
List<Integer> x=new ArrayList<Integer>();
List<String[]> y=new ArrayList<>();
List<String> list=new ArrayList<>();
List list1=new ArrayList<>();
-
ArrayList函数调用
- 向集合添加数据 函数add返回布尔型数据——true:添加成功 false：添加失败
boolean f=list.add("张三"); list.add("李四"); list.add("王五"); - 向集合插入数据——其余数据自动后排
list.add(1,"测试"); - 获取集合长度
System.out.println(list.size()); //4 - 获取集合元素
System.out.println(list.get(2));//李四 - contains：检查元素是否在集合中 返回boolean
System.out.println(list.contains("王五")); - 删除元素
list.remove(2);//通过下标删除 list.remove("王五");//通过元素删除集合元素 - 检查是否为空 返回boolean
list.isEmpty(); - 清空集合
list.clear(); - subList:获取部分集合
List<String> newlist= list.subList(0,2); - toArray:集合转换为数组
Object []str=list.toArray(); System.out.println(Arrays.toString(str));//[张三, 测试]
- 向集合添加数据 函数add返回布尔型数据——true:添加成功 false：添加失败
-
遍历集合输出
- 循环遍历
//遍历列表输出
for(String str:list)
{
System.out.println(str);//张三、测试、李四、王五
}
- 迭代器循环：Iterator<泛型>
- 若无泛型，迭代器返回Object对象
- 若有泛型，则迭代器返回相应数据对象
//迭代器:快速遍历
Iterator iterator=list.iterator();
//hasNext():返回Boolean值 ——true 存在下一条数据
while(iterator.hasNext()){
Object s=iterator.next();
System.out.println(s);
}
//迭代器:快速遍历
Iterator<String> iter=list.iterator();
while(iterator.hasNext()){
String str=iter.next();
System.out.println(str);
}
2、LinkedList（链表：查找慢、增删快）
- LinkedList采用链表存储方式，插入、删除元素时效率比较高
- 通过List接口 创建LinkedList 集合，LinkedList 与 ArrayList使用方法 一致
List<String> list=new LinkedList<>();
- 通过LinkedList 创建LinkedList 集合 ，调用LinkedList特有方法
LinkedList<String> linkedList=new LinkedList();
linkedList.add("张三");
linkedList.addFirst("刘四");
linkedList.addLast("赵武");
for(Object ll:linkedList){
System.out.println(ll);
}//刘四\张三\赵武
System.out.println(linkedList.getFirst());//刘四
System.out.println(linkedList.getLast());//赵武
linkedList.removeFirst();//删除刘四
linkedList.removeLast();//删除赵武
3、HashSet（不能有重复值，重复值只保留一个，无序的对象）
- 通过Set接口 创建HashSet 集合，HashSet与 ArrayList使用方法 一致
Set<String> set= new HashSet<>();
//添加
set.add("张三");
//长度
set.size();
//检查是否存在
set.contains("张三");
//判断是否为空
set.isEmpty();
//删除
set.remove("张三");
//清空
set.clear();
//遍历
for (String str : set) {
System.out.println(str);
}
//转变为数组
Object s[]=set.toArray();
System.out.println(Arrays.toString(s));
//迭代器遍历
Iterator<String> iterator=set.iterator();
while (iterator.hasNext()){
String str=iterator.next();
System.out.println(str);
}
- 通过 set 解决重复值问题
String s = "165,468,6584,641,6,5846,6,51,6,84,51,84,6";
String str[] = s.split(","); //split：以“，”为分隔符，存储数据
Set<String> stringSet = new HashSet<>();
for (String ss : str) {
stringSet.add(ss); //将数组数据放入集合中
}
for (String ss : stringSet) { //遍历输出
System.out.println(ss);
}
4、HashMap（键值对集合，键不可重复）
Map<String,String> stringMap= new HashMap<>();
//键入数值
stringMap.put("key","value1");
stringMap.put("key1","value2");
stringMap.put("key","value3");
//查询 键值key对应的值 键值不可相同若相同垢面的赋值覆盖前者
System.out.println(stringMap.get("key")); //value3
//集合长度
System.out.println(stringMap.size()); //2
//判断是否为空
System.out.println(stringMap.isEmpty());
//判断key是否存在
System.out.println(stringMap.containsKey("key"));
//判断value是否存在
System.out.println(stringMap.containsValue("value3"));
//替换（更改） 值
stringMap.replace("key","替换值");//由（key,value3）变为（key,替换值）
//通过key 删除value
stringMap.remove("key");
//keySet() :获取map集合所有的key值
Set<String> key =stringMap.keySet();//
for (String s : key) {
System.out.println(key+stringMap.get(s));
}
//迭代器 :获取map集合所有的key值
Iterator<String> key_1= stringMap.keySet().iterator();
//hasNext() 判断是否存在下一个值;next() 下一个 值
while(key_1.hasNext()){
System.out.println(key_1.next());
}
//迭代器 :获取map集合所有的value值
Iterator<String> values = stringMap.values().iterator();
while(values.hasNext()){
System.out.println(values.next());
}
- Hashmap 与 HashTable 区别：
- Hashtable是线程安全的，它的每个方法中都加入了Synchronize方法。在多线程并发的环境下，可以直接使用Hashtable，不需要自己为它的方法实现同步；HashMap不是线程安全的，在多线程并发的环境下，可能会产生死锁等问题，使用HashMap时就必须要自己增加同步处理。
- Hashtable既不支持Null key也不支持Null value；HashMap中，null可以作为键，这样的键只有一个；可以有一个或多个键所对应的值为null。
- Hashtable默认的初始大小为11，之后每次扩充，容量变为原来的2n+1。HashMap默认的初始化大小为16。之后每次扩充，容量变为原来的2倍。
三、集合高级操作:集合的交集、并集、差集
LinkedList<String> a=new LinkedList();
a.add("A");
a.add("B");
a.add("C");
LinkedList<String> b=new LinkedList();
b.add("B");
b.add("C");
b.add("D");
- a,b 交集
a.retainAll(b); //[B, C] - a,b 差集
a.remove(b); //[A] - a,b 合并
a.addAll(b); // [A, B, C, B, C, D] - a,b 合并(无重复值——先取差集再取合集)
a.remove(b); //[A]
a.addAll(b); // [A, B, C, D]
2255
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
