package demo211125;
public class TestA {
// 算法
// 排序+查找 // 冒泡-升序
// 1-比较相邻的两个元素。若第一个比第二个大，就交换这两个元素
// 2-一次对每一对相邻的两个元素做同样的工作，一轮次后木末尾元素为最大值
// 3-除去该轮次得到的末尾元素外．再次对剩余所有的元素重复步骤1~3过程，直到无剩余元素。
public static void main(String[] args) {
int[] a = new int[] { 1, 5, 7, 6, 2, 4 };
TestA ta = new TestA();
ta.print(a);
ta.bubbleSort(a);
ta.print(a);
ta.bubbleSort1(a);
ta.print(a);
}
public void bubbleSort(int[] arr) {// 冒泡排序---升序
int len = arr.length;
for (int i = 0; i < len - 1; i++) {
for (int j = 0; j < len - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
public void bubbleSort1(int[] arr) {// 冒泡排序--降序
int len = arr.length;
for (int i = 0; i < len - 1; i++) {
for (int j = len - 1; j > 0; j--) {
if (arr[j] > arr[j - 1]) {
int temp = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = temp;
}
}
}
}
//输出--可被当作方法调用
public void print(int[] array) {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + "\t");
}
System.out.println();
} // 1-冒泡---*需掌握
// 2-选择---*需掌握
// 3-插入---*需掌握
// 4-希尔
// 5-归并
// 6-堆
// 7-计数
// 8-桶排序
// 9-基数排序
// 10-快速排序-------------------*必掌握，面试可能考
// 1-顺序查找
// 2-二分法查找
// 3-插值查找
// 4-斐波那契查找
// 5-树表查找
// 6-分块查找
// 7-哈希查找
}
package demo211125;
//ArrayList集合相关问题
import java.util.ArrayList;
import java.util.LinkedList;
public class TestB {
// 集合定义
ArrayList<String> arrayist;// 变量类型 变量名称
// 泛型：泛指某种引用类型
// <String>集合中存储字符串类型
// <泛型>：集合中存储的元素类型 int[] a1;
// 数组：元素类型（int/Integer）+长度固定（元素的个数）+[index]/length下表/长度
// 结合：元素类型（Integer）+长度不定（元素的个数）+方法调用
ArrayList<String> a2;
public void testList() {
// 数组的操作基于索引的取值和赋值+以及长度
// 集合的操作基于方法调用的方式，实现功能：增删改查+长度...
ArrayList<String> list = new ArrayList<String>();// 引用类型变量标准类型
// ArrayList<String> list = new ArrayList<>();//String可写可不写
// .add--加数据
// 标准格式：对象名.add("所要添加的元素")
list.add("aaa");
System.out.println(list);
list.add("bbb");
System.out.println(list);
list.add("ccc");
System.out.println(list);
// list.add(0, "www");
// System.out.println(list);
list.add(1, "Add");
System.out.println(list);
// list.add(2, "www");
// System.out.println(list);
// 删数据
// list.remove(2);
// System.out.println(list);
list.remove("Add");
System.out.println(list);
// /set---修改数据
// 标准格式：对象名.set(所要修改的元素的位置，"修改后的值")
list.set(2, "Set");
System.out.println(list);
// .get---查数据
// 标准格式：对象名.get("所要查找的位置")
String val = list.get(1);
System.out.println(val);
// .size---集合元素个数
// 标准格式：对象名.add()
int size = list.size();
System.out.println(size);
// 包含--判断是否存在某个元素
// 标准格式：对象名.add("所要判断的元素")
Boolean bl = list.contains("aaa");// ontains-- 包含
System.out.println(bl);
}输出结果：
// ArrayList（数组列表） 和 LinkedList（链表列表）主要区别
// 1-
// ArrayList是实现了基于动态数组的数组的数据结构
// LinkedList是实现了基于双向链表的数组的数据结构
// 2-
// 对于随机访问（get/set）操作，ArrayList优于LinkedList
// 随机访问----借助索引号的方式快速访问
// 因为LinkedList链表结构，从头节点依次移动指针方式来访问查找
// 3-
// 对于增加/删除（add/remove）LinkedList优于ArrayList
// 因为ArrayList链表结构，需要移动数据位置来进行增删改查
// 1-索引方式正序遍历时删除元素，必须注意索引号，避免遍历遗漏元素或索引越界
// 2-索引方式逆序遍历时删除元素时，正确运行。
// 3-迭代器方式遍历是删除元素，运行正确
// PS:切记不要使用集合对象
// 4-for循环增强型遍历时删除元素
// 4.1-一次删除后，执行break / return，正确运行。
// 4.2-删除元素是倒数第二个，则不出现异常，但最后一个元素未被遍历到
// 4.3-除了上述两个情况外，删除时会出现异常
//遍历集合中的元素
public void Test1(ArrayList<String> list) {// 遍历
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));// get？？？
}
// for(A:B){C}
// B:线性集合和数组
// A:元素类型变量名称(迭代遍历的每个元素)
for (String s : list) {
System.out.println(s);
}
} public void Test2() {
ArrayList<String> a1 = new ArrayList<String>();
a1.add("aa");
a1.add("ab");
a1.add("ac");
System.out.println(a1);
ArrayList<String> a2 = new ArrayList<String>();
a2.add("bb");
System.out.println(a2);
a2.addAll(a1);//把a1的元素全部放在a2后
System.out.println(a2);
boolean b1 = a2.contains("aa");
System.out.println(b1);
}
输出结果：
}
//判断集合是否为空
public void Test3() {
// 判空
//标准格式：对象名.isEmpty()--输出结果为true或false--如果此列表不包含元素，则返回 true 。
// 有无对象+有无长度
ArrayList<String> a1 = null;
// System.out.println(a1.size());//空指针异常
ArrayList<String> a2 = new ArrayList<String>();// 有对象+无长度
System.out.println(a1 == null);// true--a1为空
System.out.println(a2 == null);// false--a2不为空
System.out.println(a2.size());// 0
System.out.println(a2.isEmpty());//true---判断是不是空
System.out.println(a2);//[]--此列表不包含元素
//判断是否为空的常用方法
if (a2 == null || a2.isEmpty()) {
}
if (a2 != null || !a2.isEmpty()) {
}
}输出结果：
public void Test4() {
// ArrayList
LinkedList<String> list = new LinkedList<>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
System.out.println(list);// [aaa, bbb, ccc]
String s = list.peek();// 单纯返回第一个[aaa]
System.out.println(s);// [aaa, bbb, ccc]
System.out.println(list);
s = list.poll();// 队列先进先出
System.out.println(s);// aaa
System.out.println(list);// [bbb,ccc]
list.pop();// 弹出第一个元素
System.out.println(list);// [ccc]
list.push("fff");//弹进
System.out.println(list);// [fff, ccc]
list.push("ddd");
System.out.println(list);// [ddd, fff, ccc]
}输出结果：
public void Test5() {
Vector<String> v1 = new Vector<>();//线程安全
// Arrays
ArrayList<Integer> la = new ArrayList<>();
Collections.addAll(la, 1, 2, 3, 4);
List<Object> list = Collections.synchronizedList(null);
}public static void main(String[] args) {
ArrayList<String> list = new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
list.add("eee");
System.out.println(list);
for (int i = list.size() - 1; i >= 0; i--) {
System.out.println("！！" + i + "\t" + list.get(i) + "\t" + list.size());
String p = list.get(i);
if ("bbb".equals(p)) {
list.remove(p);
}
System.out.println("！！" + i + "\t" + list.get(i) + "\t" + list.size());
}
System.out.println(list);
// System.out.println("******************************");
// Iterator<String> ite = list.iterator();// 迭代器
// while (ite.hasNext()) {
// String s = ite.next();
// if ("bb".equals(s)) {
// ite.remove();// 迭代器方法
// }
// }
System.out.println("***************");
for (String p : list) {// 不要用for的增强型来改变集合的个数
System.out.println("---" + p);
if ("eee".equals(p)) {
list.remove(p);
break;
}
System.out.println(list);
}
System.out.println(list);
}
@Test
public void Test5() {
Vector<String> v1 = new Vector<>();// 线程安全
// Arrays
ArrayList<Integer> la = new ArrayList<>();
Collections.addAll(la, 1, 2, 3, 4);
List<Object> list = Collections.synchronizedList(null);
} 输出结果：
package demo211125;
import java.util.HashSet;
import java.util.Iterator;
import java.util.TreeSet;
import org.junit.jupiter.api.Test;
public class TestC {
// set
HashSet<String> hashset;
public void test2() {//有序集合（自然顺序/自定义顺序）
//自然顺序：比对大小，比已有数据小，放在左子节点
TreeSet<String> t = new TreeSet<>();
t.add("c");//c
t.add("d");//c d
t.add("f");//c d f
t.add("a");//a c d f
t.add("b");//a b c d f
t.add("e");//a b c d e f
System.out.println(t);//[a, b, c, d, e, f]
System.out.println("a".compareTo("b"));//-1
//compareTo()方法:整个思路非常简单，跟字典排序是一样的，
//即比较参与的两个字符串，如果首字符相同，则比较下一个字符，直到有不同的为止，
//返回不同的字符之间的ASC码差值。如果两个字符串不一样长，
//参与比较的字符又完全一样（即一个是另一个的子串），则返回两个字符串的长度差值。
//（负数表示第一个串小，0表示两串相等，正数表示第一串较大）。
System.out.println("a".compareTo("a"));//0
System.out.println("b".compareTo("a"));//1
System.out.println("ba".compareTo("a"));//1
System.out.println("abcdef".compareTo("ace"));
//-1---b比c的ASC码值小1,b(ASC)-c(ASC)=-1
TreeSet<Integer> t1 = new TreeSet<>();
}输出结果：
@Test
public void test1() {
HashSet<String> s1 = new HashSet<>();
s1.add("bbb");
s1.add("aaa");
s1.add("ccc");
System.out.println(s1);
// s1.remove("aaa");
// 没有索引
// ArrayList-有索引+有序（默认添加的顺序与迭代遍历的顺序相同）+可重复
// HashSet-无索引+无序（默认添加的顺序与迭代遍历的顺序不同）+不可重复
System.out.println(s1.size());
for (String s : s1) {
System.out.println(s);
}
Iterator<String> it = s1.iterator();// 迭代器
while (it.hasNext()) {
System.out.println(it.next());
}
}输出结果：
}
package demo211125;
import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;
import org.junit.jupiter.api.Test;
public class TestD {
// 1-控制台输入姓名存入集合中
// 2-查询姓王的姓名，并存入新集合中，输出新集合
@Test
public void test1() {
// 1-控制台输入姓名存入集合中
Scanner sc = new Scanner(System.in);
ArrayList<String> names = new ArrayList<String>();
while (true) {
System.out.println("请输入姓名：");
String name = sc.nextLine();
names.add(name);
System.out.println("是否结束输入：(y/n)");
if ("y".equals(sc.nextLine())) {//.equals比较字符串内容是否相同
break;
}
}
// 2-查询姓王的姓名，并存入新集合中，输出新集合
System.out.println("输入的姓名为：");
System.out.println(names);
ArrayList<String> newnames = new ArrayList<>();
for (String name : names) {
if (name.charAt(0) == '王') {
newnames.add(name);
}
}
System.out.println(newnames);
} // 1-随机(输入)N个整数存入集合
// 2-在该集合中，进行(冒泡)排序，后遍历输出集合元素
@Test
public void test2() {
// 1-随机(输入)N个整数存入集合
System.out.println("请输入整数个数");
ArrayList<Integer> intNum = new ArrayList<>();
Scanner sc = new Scanner(System.in);
String sc1 = sc.nextLine();
int n = Integer.parseInt(sc1);
Random ra = new Random();
// while (true) {
for (int i = 0; i < n; i++) {
intNum.add(ra.nextInt(100));
// }
// break;
}
System.out.println("整数集合为：");
System.out.println(intNum);
// 2-在该集合中，进行(冒泡)排序，后遍历输出集合元素
int size = intNum.size();
for (int i = 0; i < size; i++) {
for (int j = 0; j < size - 1; j++) {
int p = intNum.get(j);
int q = intNum.get(j + 1);
if (intNum.get(j) > intNum.get(j + 1)) {
// 此时为冒泡正排序（由小至大），
// 把>换为<即为冒泡逆排序（由大至小）
intNum.set(j + 1, p);
intNum.set(j, q);
}
}
}
System.out.println("排序后的整数集合为：");
System.out.println(intNum);
}}
package demo211125;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Properties;
import java.util.Set;
import java.util.TreeMap;
import java.util.concurrent.ConcurrentHashMap;
public class TestE {
// HashMap
HashMap<String, String> hashmap;
HashSet<String> hashset;
// java数据结构中的映射定义了一个接口java.util.map;
// 实现类HashMap Hashtable LinkedHashMap TreeMap
// 用于存储键值对 key-value(键-值),可以根据key得到value
// 因此不允许key重复（重复则会覆盖），但是允许value重复
// HashMap
// 根据key的hashcode的值存储结构,根据key的值直接获取对应value，具有很快的访问速度
// HashSet和HashMap底层结构一致，所以HashMap也是无序的
public static void main(String[] args) {
HashMap<String, String> map = new HashMap<>();
// map.put 添加修改两个功能
map.put("101", "zhangsan");
map.put("aa", "a1");
System.out.println(map);// {aa=a1, 101=zhangsan}
map.put("aa", "a2");
System.out.println(map);// {aa=a2, 101=zhangsan}
// 删除---key
// 标准格式：方法名.remove
map.remove("aa");
System.out.println(map);// 输出集合中剩下的元素{101=zhangsan}
// 查找---key对应的value
// 标准格式：方法名.get
String b1 = map.get("101");
System.out.println(b1);// 输出key对应的value：zhangsan
String val = map.get("123");
System.out.println(val);// null
// 集合的长度
// 返回此映射中的（泛型）键值映射的数量
System.out.println(map.size());// 1
// 判断集合中是否存在指定键的映射
// 如果该映射包含指定键的映射,则输出true
// containsKey() 方法检查 hashMap 中是否存在指定的 key 对应的映射关系。
// 标准格式：方法名.containsKey(key)
System.out.println(map.containsKey("aa1"));// false
// 判断 Map 集合中是否包含指定的键值。
// 如果 Map 集合中包含指定的键值对象，则返回 true，否则返回 false。
// 标准格式：方法名.containsValue(value)
boolean b2 = map.containsValue("zhangsan");// true
System.out.println(b2);
boolean b3 = map.containsValue("a1");// false
System.out.println(b3);
boolean b4 = map.containsValue("a2");// false
System.out.println(b4);
// 遍历
Set<Entry<String, String>> entry = map.entrySet();
// Entry--节点--键值对--每一个键值对也就是一个Entry、
// 第一个String是key,第一个String是value,
for (Entry<String, String> e : map.entrySet()) {
// Entry<String, String>键值对的集合
// .entrySet()是 java中 键-值 对的集合
System.out.println(e.getKey() + " " + e.getValue());// 101 zhangsan
// .getKey()
// .getValue()
}
Set<String> keys = map.keySet();// 键的集合
for (String key : keys) {
System.out.println(key);// 101
}
// Set<String> values = map.values();// 值的集合
for (String value : map.values()) {
System.out.println(value);//zhangsan
}
TreeMap<String, String> treemap;// TreeSet
Hashtable<String, String> hashtable;// 线程安全 synchronized
Properties properties;// 属性集合（属性名-属性值）【定义无泛型】
LinkedHashMap<String, String> linghashmap;
// 按照存入的顺序存储数据--有序集合
}
// 底层数据结构
// HashMap （>=JDK1.7） 数组+链表
// HashMap （<=JDK1.7） 数组+链表/红黑树 的转换
// TreeMap 红黑树
// HashMaop 最多只允许一个记录的key=null，允许多个记录的value=null
// 不支持线程同步（线程不安全），即任一时刻可有多个线程同时写入hashmap
// 从而可能导致数据不一致（错乱）
public void test() {
Map<Object, Object> map = Collections.synchronizedMap(null);
ConcurrentHashMap<String, String> m;
}}
2291
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
