Java_集合总结_01

最新推荐文章于 2023-02-25 19:53:19 发布
最新推荐文章于 2023-02-25 19:53:19 发布
阅读量117 收藏
点赞数 2
分类专栏： 代码块 总结 初学Java 文章标签： 集合 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46613077/article/details/115488359
版权
总结 同时被 3 个专栏收录
32 篇文章 0 订阅
订阅专栏
初学Java
5 篇文章 0 订阅
订阅专栏
代码块
3 篇文章 0 订阅
订阅专栏

Java_集合总结_01

本文主要是对集合的学习与应用。通过对集合中常规使用的集合方式举例说明并进行总结。

文章目录

什么是集合？

在认识集合之前，先思考一个问题：
在编程中常常需要集中存放多个数据，虽然可以使用数组来存放保存，但数组的长度不可变化，一旦初始化了数组长度，这个数组就是不可变的，那么如何存储动态变化的数据呢？

你想到了吗？没错，这就是接下来要介绍的知识：集合。
为了保存不确定的数据以及保存具有映射关系的数据，java提供了集合类。

数组集合
存储基本数据类型或引用数据类型只存储引用数据类型
存储长度固定存储动态可变

集合框架中主要关系示意图：
集合框架关系

本文主要就Set、List、Map的部分子类，通过举例的方式进行对常用的集合进行说明、归纳、总结。

一、Set集合

Set就类似于一个罐子，程序可以依次把多个对象丢进去，不记它的顺序。
特点：无序、无下标、不可以重复。
Set集合与Collection基本相同，没有提供额外的方法，只是行为有些不同。（不允许包含相同的元素）

Set方法

返回值方法描述
booleanadd(E e)如果指定的元素不存在，则将其指定的元素添加（可选操作）。
booleanaddAll(Collection<? extends E> c)将指定集合中的所有元素添加到此集合（如果尚未存在）（可选操作）。
voidclear()从此集合中删除所有元素（可选操作）。
booleancontains(Object o)如果此集合包含指定的元素，则返回 true 。
booleancontainsAll(Collection<?> c)返回 true如果此集合包含所有指定集合的元素。
booleanequals(Object o)将指定的对象与此集合进行比较以实现相等。
inthashCode()返回此集合的哈希码值。
booleanisEmpty()如果此集合不包含元素，则返回 true 。
Iteratoriterator()返回此集合中元素的迭代器。
booleanremove(Object o)如果存在，则从该集合中删除指定的元素（可选操作）。
booleanremoveAll(Collection<?> c)从此集合中删除指定集合中包含的所有元素（可选操作）。
booleanretainAll(Collection<?> c)仅保留该集合中包含在指定集合中的元素（可选操作）。
intsize()返回此集合中的元素数（其基数）。
defaultSpliterator spliterator()在此集合中的元素上创建一个 Spliterator 。
Object[]toArray()返回一个包含此集合中所有元素的数组。

1、HashSet

（1）哈希表边存放的是哈希值。HashSet存储元素的顺序并不是按照存入时的顺序（和List显然不同） 是按照哈希值来存的所以取数据也是按照哈希值取得。
（2）具有很好的存取和查找性能。
（3）HashSet是不同步的。如果有多个线程同时访问一个HashSet，必须通过代码来保证其同步。
（4）集合元素值可以是NULL 。

具体存储描述：
当向HashSet集合中存入一个元素时，HashSet会调用该对象的HashCode()方法来得到该对象的HashCode值，然后根据该HashCode值决定该对象在HashSet的存储位置。如果有2个元素通过equals()方法比较返回true，但它们的HashCode()方法返回值不相等，HashSet将会把它们存在不同的位置，依然可以添加成功。

举个栗子：

public class SetDemo {
    public static void main(String[] args) {

        Set<String> set = new HashSet<>();
        set.add("小红");
        set.add("小华");
        set.add("小紫");
        set.add("小紫");
        System.out.println("元素个数为：" + set.size());
        System.out.println("原始列表：" + set.toString());


//        遍历(Set无角标方法)
        System.out.println("--------for-each遍历-------");
        for (String s: set) {
            System.out.println(s);
        }

        System.out.println("--------迭代器遍历-------");
        Iterator<String> iterator=set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
        System.out.println("--------集合是否包含某个对象--------");
        System.out.println("输入你要查询的对象：");
        Scanner scanner=new Scanner(System.in);
        String s=scanner.next();
        if (set.contains(s)) {
            System.out.println("此集合包含"+s);
        }
        else{
            System.out.println("此集合不包含"+s);
        }
    }
}

结果

元素个数为：3
原始列表：[皮尺, 憨憨, 白白]
--------for-each遍历-------
皮尺
憨憨
白白
--------迭代器遍历-------
皮尺
憨憨
白白
--------集合是否包含某个对象--------
输入你要查询的对象：
白白
此集合包含白白
(or)
输入你要查询的对象：
黑黑
此集合不包含黑黑

二、List集合

（1）List集合是允许使用重复元素。
（2）默认按照元素的添加顺序设置元素的索引。
（3）有序、有下标、可重复。

List实现了Collection里的所有方法。
同时添加了一些根据索引来操作集合元素的方法。

返回值方法描述
booleanadd(E e)将指定的元素追加到此列表的末尾（可选操作）。
voidadd(int index, E element)将指定的元素插入此列表中的指定位置（可选操作）。
booleanaddAll(Collection<? extends E> c)按指定集合的迭代器（可选操作）返回的顺序将指定集合中的所有元素附加到此列表的末尾。
booleanaddAll(int index, Collection<? extends E> c)将指定集合中的所有元素插入到此列表中的指定位置（可选操作）。
voidclear()从此列表中删除所有元素（可选操作）。
booleancontains(Object o)如果此列表包含指定的元素，则返回 true 。
booleancontainsAll(Collection<?> c)如果此列表包含指定 集合的所有元素，则返回true。
booleanequals(Object o)将指定的对象与此列表进行比较以获得相等性。
Eget(int index)返回此列表中指定位置的元素。
inthashCode()返回此列表的哈希码值。
intindexOf(Object o)返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。
booleanisEmpty()如果此列表不包含元素，则返回 true 。
Iteratoriterator()以正确的顺序返回该列表中的元素的迭代器。
intlastIndexOf(Object o)返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
ListIteratorlistIterator()返回列表中的列表迭代器（按适当的顺序）。
ListIteratorlistIterator(int index)从列表中的指定位置开始，返回列表中的元素（按正确顺序）的列表迭代器。
Eremove(int index)删除该列表中指定位置的元素（可选操作）。
booleanremove(Object o)从列表中删除指定元素的第一个出现（如果存在）（可选操作）。
booleanremoveAll(Collection<?> c)从此列表中删除包含在指定集合中的所有元素（可选操作）。
default voidreplaceAll(UnaryOperator operator)将该列表的每个元素替换为将该运算符应用于该元素的结果。
booleanretainAll(Collection<?> c)仅保留此列表中包含在指定集合中的元素（可选操作）。
Eset(int index, E element)用指定的元素（可选操作）替换此列表中指定位置的元素。
intsize()返回此列表中的元素数。
default voidsort(Comparator<? super E> c)使用随附的 Comparator排序此列表来比较元素。
default Spliteratorspliterator()在此列表中的元素上创建一个Spliterator 。
ListsubList(int fromIndex, int toIndex)返回此列表中指定的 fromIndex （含）和 toIndex之间的视图。
Object[]toArray()以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组。

1.ArrayList

（1）ArrayList是连续的、基于动态数组的数据结构。
（2）ArrayList的查询与修改较快。
（3）封装了一个动态的、允许再分配的Object[]数组。
（4）其线程不安全。当多个线程访问同一个ArrayList时，若有同时超过一个线程修改集合，必须手动保证该集合的同步性。
（5）若想把它变成安全的，需要用到Collections工具类。

举个栗子：

public class CollectionDemo2 {
    public static void main(String[] args) {
        Collection collection = new ArrayList();
        Student s1 = new Student("小凰", 21);
        Student s2 = new Student("小驴", 20);
        Student s3 = new Student("小箐", 20);
        Student s4 = new Student("小婪", 19);
        Student s5 = new Student("小姊", 18);

        collection.add(s1);
        collection.add(s2);
        collection.add(s3);
        collection.add(s4);
        collection.add(s5);
        System.out.println("列表元素个数为：" + collection.size());
//        删除
//        collection.remove(s1);
//        System.out.println("删除后列表元素个数为：" + collection.size());
//        不会删除上述列表中相应的学生信息
//        collection.remove(new Student("小箐", 20));

//        遍历
        System.out.println("--------for-each遍历-------");
        for (Object student : collection) {
            Student s = (Student) student;
            System.out.println(student.toString());
        }
        System.out.println("--------迭代器遍历-------");
        Iterator iterator=collection.iterator();
        while (iterator.hasNext()){
            Object obj=(Object) iterator.next();
            System.out.println(obj);
        }
    }
}

结果

列表元素个数为：5
--------for-each遍历-------
Student{name=‘小凰’, age=21}
Student{name=‘小驴’, age=20}
Student{name=‘小箐’, age=20}
Student{name=‘小婪’, age=19}
Student{name=‘小姊’, age=18}
--------迭代器遍历-------
Student{name=‘小凰’, age=21}
Student{name=‘小驴’, age=20}
Student{name=‘小箐’, age=20}
Student{name=‘小婪’, age=19}
Student{name=‘小姊’, age=18}

//使用集合工具类
public class CollectionsDSemo {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(20);
        list.add(12);
        list.add(28);
        list.add(90);
        list.add(43);
//        sort排序
        System.out.println("排序之前:" + list.toString());
        Collections.sort(list);
        System.out.println("排序之后" + list.toString());

//        binarySearch二分查找
        int i1 = Collections.binarySearch(list, 20);
        System.out.println(i1);
        int i2 = Collections.binarySearch(list, 12);
        System.out.println(i2);
        int i3 = Collections.binarySearch(list, 28);
        System.out.println(i3);
        int i4 = Collections.binarySearch(list, 90);
        System.out.println(i4);
        int i5 = Collections.binarySearch(list, 43);
        System.out.println(i5);

//        copy赋值
        List<Integer> dest = new ArrayList<>();
        for (int k = 0; k < list.size(); k++) {
            dest.add(0);
        }
        Collections.copy(dest, list);
        System.out.println("copy赋值后"+dest.toString());

//        reserve反转
        Collections.reverse(list);
        System.out.println("反转之后:" + list);
//        shuffle打乱
        Collections.shuffle(list);
        System.out.println("打乱之后:" + list);

//        补充:list转成数组
        System.out.println("-----list转成数组------");
        Integer[] arr = list.toArray(new Integer[0]);
        System.out.println(arr.length);
        System.out.println(Arrays.toString(arr));
//        补充:数组转成集合
        String[] names = {"张三", "李四", "赵七"};
        List<Integer> list1 = Arrays.asList(arr);
//        不允许删除\添加,集合是一个受限集合
//        list1.add("王五");
        list1.remove("张三");
        System.out.println(list1);
    }
}

结果

排序之前:[20, 12, 28, 90, 43]
排序之后[12, 20, 28, 43, 90]
1
0
2
4
3
copy赋值后[12, 20, 28, 43, 90]
反转之后:[90, 43, 28, 20, 12]
打乱之后:[28, 43, 90, 20, 12]
-----list转成数组------
5
[28, 43, 90, 20, 12]
[28, 43, 90, 20, 12]

2.LinkedList

（1）LinkedList是基于链表的数据结构，它是一个双向链表。
（2）LinkedList的增加与查询较快。
（3）实现了Deque接口，可被当作双端队列来使用。

举个栗子：

public class LinkedListDemo1 {

    public static void main(String[] args) {
        LinkedList linkedList = new LinkedList<>();

        Student s1 = new Student("小凰", 21);
        Student s2 = new Student("小驴", 20);
        Student s3 = new Student("小箐", 20);
        Student s4 = new Student("小婪", 19);
        Student s5 = new Student("小姊", 18);

        linkedList.add(s1);
        linkedList.add(s2);
        linkedList.add(s3);
        linkedList.add(s4);
        linkedList.add(s5);

        System.out.println("列表元素个数为：" + linkedList.size());
        System.out.println(linkedList.toString());

        linkedList.remove(new Student("小凰", 21));//重写equals了
//        linkedList.remove(s1);
        System.out.println("删除之后：" + linkedList.size());
        System.out.println(linkedList.toString());

//        遍历
        System.out.println("-----------for -----------");
        for (int i=0;i<linkedList.size();i++){
            System.out.println(linkedList.get(i));//返回此列表中指定位置的元素
        }
        System.out.println("--------for-each遍历-------");
        for (Object obj: linkedList) {
            Student s=(Student)obj;
            System.out.println(obj);
//            System.out.println(s.toString());
        }
        System.out.println("--------迭代器遍历-------");
        Iterator iterator=linkedList.iterator();
        while(iterator.hasNext()){
            Student s=(Student)iterator.next();
            System.out.println(s.toString());
        }
        ListIterator listIterator=linkedList.listIterator();
        System.out.println("--------列表迭代器：前-后-------");
        while(listIterator.hasNext()){
            System.out.println(listIterator.nextIndex()+":"+listIterator.next());
        }
//        hasPrevious方法必须在上面的hasNext方法用完后才可以使用.不然直接用,不会生效.
        System.out.println("--------列表迭代器：后-前-------");
        while(listIterator.hasPrevious()){
            System.out.println(listIterator.previousIndex()+":"+listIterator.previous());
        }

    }
}

结果

列表元素个数为：5
[Student{name=‘小凰’, age=21}, Student{name=‘小驴’, age=20}, Student{name=‘小箐’, age=20}, Student{name=‘小婪’, age=19}, Student{name=‘小姊’, age=18}]
删除之后：4
[Student{name=‘小驴’, age=20}, Student{name=‘小箐’, age=20}, Student{name=‘小婪’, age=19}, Student{name=‘小姊’, age=18}]
-----------for -----------
Student{name=‘小驴’, age=20}
Student{name=‘小箐’, age=20}
Student{name=‘小婪’, age=19}
Student{name=‘小姊’, age=18}
--------for-each遍历-------
Student{name=‘小驴’, age=20}
Student{name=‘小箐’, age=20}
Student{name=‘小婪’, age=19}
Student{name=‘小姊’, age=18}
--------迭代器遍历-------
Student{name=‘小驴’, age=20}
Student{name=‘小箐’, age=20}
Student{name=‘小婪’, age=19}
Student{name=‘小姊’, age=18}
--------列表迭代器：前-后-------
0:Student{name=‘小驴’, age=20}
1:Student{name=‘小箐’, age=20}
2:Student{name=‘小婪’, age=19}
3:Student{name=‘小姊’, age=18}
--------列表迭代器：后-前-------
3:Student{name=‘小姊’, age=18}
2:Student{name=‘小婪’, age=19}
1:Student{name=‘小箐’, age=20}
0:Student{name=‘小驴’, age=20}

三、Map集合

（1）Map用于保存具有映射关系的数据，因此Map集合里保存着两组值（key,value）
（2）key不可以重复，value可以重复。

返回值方法描述
voidclear()从该地图中删除所有的映射（可选操作）。
default Vcompute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)尝试计算指定键的映射及其当前映射的值（如果没有当前映射， null ）。
default VcomputeIfAbsent(K key, Function<? super K,? extends V> mappingFunction)如果指定的键尚未与值相关联（或映射到 null ），则尝试使用给定的映射函数计算其值，并将其输入到此映射中，除非 null 。
default VcomputeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)如果指定的密钥的值存在且非空，则尝试计算给定密钥及其当前映射值的新映射。
booleancontainsKey(Object key)如果此映射包含指定键的映射，则返回 true 。
booleancontainsValue(Object value)如果此地图将一个或多个键映射到指定的值，则返回 true 。
Set<Map.Entry<K,V>>entrySet()返回此地图中包含的映射的Set视图。
booleanequals(Object o)将指定的对象与此映射进行比较以获得相等性。
default voidforEach(BiConsumer<? super K,? super V> action)对此映射中的每个条目执行给定的操作，直到所有条目都被处理或操作引发异常。
Vget(Object key)返回到指定键所映射的值，或 null如果此映射包含该键的映射。
default VgetOrDefault(Object key, V defaultValue)返回到指定键所映射的值，或 defaultValue如果此映射包含该键的映射。
inthashCode()返回此地图的哈希码值。
booleanisEmpty()如果此地图不包含键值映射，则返回 true 。
SetkeySet()返回此地图中包含的键的Set视图。
default Vmerge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)如果指定的键尚未与值相关联或与null相关联，则将其与给定的非空值相关联。
Vput(K key, V value)将指定的值与该映射中的指定键相关联（可选操作）。
voidputAll(Map<? extends K,? extends V> m)将指定地图的所有映射复制到此映射（可选操作）。
default VputIfAbsent(K key, V value)如果指定的键尚未与某个值相关联（或映射到 null ）将其与给定值相关联并返回 null ，否则返回当前值。
Vremove(Object key)如果存在（从可选的操作），从该地图中删除一个键的映射。
default booleanremove(Object key, Object value)仅当指定的密钥当前映射到指定的值时删除该条目。
default Vreplace(K key, V value)只有当目标映射到某个值时，才能替换指定键的条目。
default booleanreplace(K key, V oldValue, V newValue)仅当当前映射到指定的值时，才能替换指定键的条目。
default voidreplaceAll(BiFunction<? super K,? super V,? extends V> function)将每个条目的值替换为对该条目调用给定函数的结果，直到所有条目都被处理或该函数抛出异常。
intsize()返回此地图中键值映射的数量。
Collectionvalues()返回此地图中包含的值的Collection视图。

1、HashMap

（1）HashMap通过hashcode对其内容进行快速查找
（2）HashMap是基于哈希表的Map实现的。
（3）允许使用null键和null值。
（4）所有已实现的接口： Serializable, Cloneable, Map<K,V> 。
（5）HashMap：适用于在Map中插入、删除和定位元素。
（6）非线程安全。
下面主要通过linkedHashMap来举个栗子：

public class MapDemo {

    public static void main(String[] args) {
        LinkedHashMap<String,String> linkedHashMap=new LinkedHashMap();

        linkedHashMap.put("0","荔枝");
        linkedHashMap.put("2","苹果");
        linkedHashMap.put("3","葡萄");
        linkedHashMap.put("5","芒果");
        linkedHashMap.put("1","香蕉");
//
        System.out.println("--------Iterator遍历-------");
        Iterator it = linkedHashMap.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry entry = (Map.Entry) it.next();
            System.out.println("key:" + entry.getKey() + "   value:" + entry.getValue());
        }
        System.out.println("--------for-each--------");
//        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (String key:linkedHashMap.keySet()) {
            System.out.println("key= "+key+" and value= "+linkedHashMap.get(key));
        }
        for (Map.Entry<String, String> entry:linkedHashMap.entrySet()) {
            String value = entry.getValue();
            String key = entry.getKey();
            System.out.println("key="+key+"\tvalue="+value);
        }
    }
}

2、TreeMap

（1）一个有序的key-value集合，它是通过红黑树实现的。
（2）继承于AbstractMap，所以它是一个Map，即一个key-value集合。
（3）实现了NavigableMap接口，意味着它支持一系列的导航方法。比如返回有序的key集合。
（4）实现了Cloneable接口，意味着它能被克隆。
（5）实现了java.io.Serializable接口，意味着它支持序列化。
（6）Treemap：适用于按自然顺序或自定义顺序遍历键(key)。
（7）非线程安全。

举个简单栗子：

public class MapDemo2 {
    public static void main(String[] args) {
        TreeMap<String,String> treeMap=new TreeMap();

        treeMap.put("0","荔枝");
        treeMap.put("2","苹果");
        treeMap.put("3","葡萄");
        treeMap.put("5","芒果");
        treeMap.put("1","香蕉");
//
        Iterator it = treeMap.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry entry = (Map.Entry) it.next();
            System.out.println("key:" + entry.getKey() + "   value:" + entry.getValue());
        }
    }
}

结果

key:0 value:荔枝
key:1 value:香蕉
key:2 value:苹果
key:3 value:葡萄
key:5 value:芒果

小小总结

本文上述已经描述了许多的内容与特点等，可以具体参观一下上述描述或者下述博客吖~
https://blog.csdn.net/u012102104/article/details/79235938
本篇文章主要是认识并了解一下集合。上述附属了一些简单的使用例子。在后续的学习中会不断更新吖~

欢迎三连@_@

葡萄籽-June
关注
专栏目录
java集合框架实验心得_关于Java集合框架的总结
weixin_32322859的博客
02-27 1774
本篇文章先从整体介绍了Java集合框架包含的接口和类，然后总结了集合框架中的一些基本知识和关键点，并结合实例进行简单分析。当我们把一个对象放入集合中后，系统会把所有集合元素都当成Object类的实例进行处理。从JDK1.5以后，这种状态得到了改进：可以使用泛型来限制集合里元素的类型，并让集合记住所有集合元素的类型。一、综述所有集合类都位于java.util包下。集合中只能保存对象(保存对象的引用变...
Java集合图解总结
qq_43975081的博客
11-26 1095
Java集合图解总结 JavaJava集合图解总结
java中的集合基础
最新发布
weixin_45834289的博客
02-25 127
集合的基本使用
java集合超详解
热门推荐
feiyan的博客
08-03 45万+
一、集合大纲 1.集合和数组的区别： 2.Collection集合的方法： 3.常用集合的分类： Collection 接口的接口 对象的集合（单列集合） ├——-List 接口：元素按进入先后有序保存，可重复 │—————-├ LinkedList 接口实现类， 链表， 插入删除， 没有同步， 线程不安全 │—————-├ ArrayList 接口...
Java学习路线总结，搬砖工逆袭Java架构师
学Java，找哪吒
09-07 25万+
定期分享Java硬核技术干货、分享Java学习路线、分享Java经典面试题
Java基础知识总结（2021版）
学Java，找哪吒
01-09 25万+
前言 大家好，我是素小暖，2012年毕业，2016年通过培训转行java开发，今天2021年1月9日，转行之路跌跌绊绊，蓦然回首，已经满满的4年工作经验了？但感觉知识还是相当的匮乏，没自信，也许是努力程度还不够吧。很感谢CSDN，因为是它给了我学习的动力，之前写了一篇记录CSDN博客访问量的文章，也许大家感觉很幼稚，但真的很有用，很有效果，仿佛磕了药一样，努力学习，进步。 2020年，是我较为成功的一年，工作上，跳了槽，涨了工资；学习上，啃了几本名著（Effective Java、重构 改善既.
Java集合框架总结
ThinkWon的博客
08-08 6万+
简介 集合框架：用于存储数据的容器。 集合框架是为表示和操作集合而规定的一种统一的标准的体系结构。 任何集合框架都包含三大块内容：对外的接口、接口的实现和对集合运算的算法。 接口：表示集合的抽象数据类型。接口允许我们操作集合时不必关注具体实现，从而达到“多态”。在面向对象编程语言中，接口通常用来形成规范。 实现：集合接口的具体实现，是重用性很高的数据结构。 算法：在一个实现了某个集合框架中的接口的...
集合知识点总结（java）
一枚数学专业的小码农的博客
07-10 6240
集合的比较全面的总结
java集合合并_【总结】Java集合之间合并与去重及元素比较的方法
weixin_35327824的博客
02-21 2102
可以用于 Java多个集合之间合并及元素比较的简单方法public static void main(String[] args) {Listlist = new ArrayList<>();Listlist2 = new ArrayList<>();list.add("aaa");list.add("李四");list.add("赵五");list2.add("aaa")...
java list集合合并_JAVA List合并集合
weixin_33236595的博客
02-19 3173
import java.util.ArrayList;import java.util.List;public class test {public static void main(String[] args) throws Exception {/*测试合并两个类型相同的list*/List list1 = new ArrayList();List list2 = new ArrayList(...
Java_SE总结.xmind
08-01
从无到有,一点一点自己总结出来,提供复习,查阅.从头过一遍基础,包括基础的程序语法,和集合,常用类,IO流,多线程,等所有的java知识点
FCM.rar_FCM java_fcm_fcm java_fcm.rar java_聚类 java
09-21
总结来说，模糊C均值聚类（FCM）是处理复杂数据分布的有效方法，它的Java实现使得在Java环境中进行聚类分析成为可能。通过理解FCM算法的原理，以及`FCM.java`的代码实现，开发者可以更好地应用这项技术，为数据分析...
Java基础_java基础_Java面试总结_源码
10-02
这份"Java基础_java基础_Java面试总结_源码"资料显然针对的是那些希望在Java开发领域找工作，尤其是应届毕业生。它涵盖了Java的基础知识以及面试中经常被问到的问题，帮助求职者准备面试。 首先，让我们来探讨Java...
java_world.rar_java office_jmf_world
09-24
总结起来，"java_world.rar_java office_jmf_world"资源集包含了与Java Office（如Apache POI）和JMF相关的代码实例，这些实例可以帮助开发者深入理解如何在Java环境中处理办公文档和多媒体内容。通过学习和实践这些...
demo.zip_Java编程_Java__Java编程_Java_
08-09
5. **使用List**: `List`是Java集合框架的一部分，它是有序的、允许重复元素的集合。常见的实现有ArrayList和LinkedList。ArrayList在内存中连续存储元素，适合随机访问；LinkedList则使用链表结构，插入和删除操作...
Idea IntelliJ 配置 Git（图文教程）
m0_46613077的博客
06-28 9249
Idea配置Git（图文详解！） 本文主要是配置Idea中的Git，从而能够使得小组合作等更加方便快捷。 文章目录Idea配置Git（图文详解！）前言一、Idea中登录GitHub账号二、配置Git三、Git 的简单使用【补充】在Terminal通过git命令进行上述步骤： 前言 配置Git之前，需要注册GitHub账号。 可自行去官网进行注册。 若注册完成，则进入配置步骤。 一、Idea中登录GitHub账号 》》》-Idea中打开File | Settings | Version Control |
数据库：“主键”
m0_46613077的博客
05-12 4775
数据库☞主键 本文主要是根据对数据库的相应学习，并对数据库中的一个重要的知识点——主键 进行总结！ 中间也会穿插其他的一些知识点，例如外键、关系型数据库吖等。 文章目录数据库☞主键前言一、概念二、设计原则三、SQL定义主键约束（实体完整性）四、在不同的关系数据库中的主键选取策略 前言 主键的应用是很重要的，这对于数据库的设计十分重要！ 关系型数据库总结—易理解！ 泛型【在整理中~后贴哦】 一、概念 主键和外键是把多个表组织为一个有效的关系数据库的粘合剂。数据库模式从理论上的逻辑设计转换为实际
Java_图书管理系统_总结1
m0_46613077的博客
04-21 2816
Java_图书管理系统_总结1 嗷呜 嗷呜 嗷呜~ 经过使用IO流操作进行编写简单的图书管理系统（控制台输出）的实践项目后，有许许多多的感受以及项目总结想在这边分享一下~ 先容我呐喊一句：终于结束了！！！ 笔者在之前主要是通过数据库对数据进行操作。 =_=本次却全部是由IO流操作存取数据。 掌握java基本语法 熟悉使用流程控制 理解面向对象思想 熟练封装，继承，多态 熟悉使用接口，异常 熟悉使用集合 熟悉掌握I/o流相关操作 目的是为了通过此次小小项目来检验自己对Java基础的掌握情况。本篇文章主要
图书馆管理系统_三层架构_MySQL
m0_46613077的博客
06-29 2232
图书馆管理系统(重构)项目_三层架构_MySQL 先前的图书馆管理系统主要通过控制台输入，存储数据通过文件进行存储。 而本次的重构图书馆管理系统虽然界面还是通过控制台输入输出，但是由于本系统重构的目的在于Java后端使用三层架构UBD与数据库MySQL进行数据的存储与访问。因此，前端采用最简单的显示方式以至于更清楚明了后端的代码功能与逻辑。 文章目录图书馆管理系统(重构)项目_三层架构_MySQL前言一、项目基础架构简介二、数据库表1.管理员表2.图书信息表3.读者信息表4.读者类型表5.借阅记录表三、三
Java集合框架总结：Collection, Map及其子类解析
"java基础之集合总结" 在Java编程中，集合是存储和管理对象的重要工具。本文档主要涵盖了Java中的单列集合Collection和双列集合Map的子类及其常用方法，旨在帮助学习者理解并掌握这些核心概念。 1. Collection接口...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值