学习大数据,所必需的java基础(6)

这篇具有很好参考价值的文章主要介绍了学习大数据,所必需的java基础(6)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

集合

Set集合介绍

1.概述:set是一个接口,是Collection下的子接口
2.使用:
a.所用的方法和Collection接口中的方法一模一样
b.set接口中的方法并没有堆Collection中的方法进行任何的扩充
c.set以及下面所有的实现类集合相当是一个傀儡
因为所用的set集合底层都是依靠map集合实现的

HashSet集合的介绍和使用

1.概述:HashSet是Set接口的实现类对象
2.特点
a.元素无序
b.元素不可重复
c.无索引
d.线程不安全
3.数据结构:哈希表
jdk8之前: 哈希表 = 数组+链表
jdk8之后:哈希表 = 数组+链表+红黑树
方法
和Collection一模一样

import java.util.HashSet;
import java.util.Iterator;

public class test08 {
    public static void main(String[] args) {
        final HashSet<String> set = new HashSet<>();
        set.add("张三");
        set.add("李四");
        set.add("王五");
        set.add("孙六");
        System.out.println(set);
        Iterator<String> iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        System.out.println("=======================");
        for (String s : set) {
            System.out.println(s);
        }
    }
}

运行结果
学习大数据,所必需的java基础(6),学习,大数据,java

LinkedHashSet的介绍以及使用

概述 LinkedHashSet extends HashSet
特点:
a.元素有序
b.元素布克重复
c.无索引
d.线程不安全
数据结构
哈希表+双向链表
使用 和HashSet一样

public static void main(String[] args) {
        final HashSet<String> set = new HashSet<>();
        set.add("张三");
        set.add("李四");
        set.add("王五");
        set.add("孙六");
        set.add("张三");
        System.out.println(set);
        Iterator<String> iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        System.out.println("=======================");
        for (String s : set) {
            System.out.println(s);
        }
    }

哈希值

概述 计算机计算出来的一个十进制数,我们可以理解为是对象的地址值
获取哈希值:Object类中的
int hashCode()
结论:
如果内容一样,哈希值一定一样
如果内容同不用,哈希值也有可能不一样

public class test10 {
    public static void main(String[] args) {
        String s1 = "abc";
        String s2 = "abc";
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
        System.out.println("==================");
        String s3 = "通话";
        String s4 = "重地";
        System.out.println(s3.hashCode());
        System.out.println(s4.hashCode());
    }
}

运行结果
学习大数据,所必需的java基础(6),学习,大数据,java

哈希值的计算方式

通过进入String的hashCode方法,查看相关的代码

public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {
            char val[] = value;

            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i];
            }
            hash = h;
        }
        return h;
    }

从上述代码中看到31作为常量相乘,31是一个质数,因为31这个数可以尽可能的解决哈希碰撞问题
尽量的不出现,内容不一样,但是哈希值一样的问题

HashSet的存储去重的过程

1.计算元素的哈希值,比较元素哈希值
2.如果哈希值不一样,直接存
3.如果哈希值一样,再比较内容(equals)
4.如果哈希值不一样,内容一样,存
5.如果哈希值一样,内容一样,去重复,后面的会把前面的覆盖掉

Map集合

Map的介绍

概述:双列集合的顶级接口
组成部分
一个元素是有两部分构成
key = value ----- 键值对

HashMap的介绍以及使用

概述:是Map的实现类
特点:
a.元素无序
b.key唯一,value可重复
c.无索引
d.线程不安全
数据结构:哈希表
常用方法
V put(K key, V value) -> 存储元素
V remove(Object key) ->根据key删除对应的键值对
V get(Object key) -> 根据key获取对应的value
boolean containsKey(Object key) ->判断Map中是否包含指定的key
Collection values() -> 将Map中所有的value存储到Collection集合中

Set keySet() -> 将Map中所有的key获取出来存到Set集合中
Set<Map.Entry<K,V>> entrySet() -> 获取Map中所有的键值对对象,放到set集合中

public class test {
    public static void main(String[] args) {
        final HashMap<Integer, String> set = new HashMap<>();
        //存储元素
        set.put(0001,"李云龙");
        set.put(0002,"丁伟");
        set.put(0003,"孔捷");
        System.out.println(set);
        //根据key删除对应的键值对
        set.remove(0001);
        System.out.println(set);
        //根据key获取对应的Value
        System.out.println(set.get(2));
        //判断map中是否含有指定的key
        System.out.println(set.containsKey(1));
    }
}

注意 如果key重复了,后米的会把前面的覆盖掉,去重复过程和set一模一样

HashMap的两种遍历方式

方式1:获取key,然后再根据key获取value

Set keySet() ----- 将Map中所有的key获取出来存到Set集合中

public class test02 {
    public static void main(String[] args) {
        final HashMap<Integer, Object> hashMap = new HashMap<>();
        hashMap.put(1,"李云龙");
        hashMap.put(2,"丁伟");
        hashMap.put(3,"孔捷");
        /*
        * 先调用keySet方法,获取map中所有的key,存储到Set集合中
        * 遍历Set集合,调用map中的get方法,根据key获取value
        * */
        Set<Integer> set = hashMap.keySet();
        for (Integer key : set) {
            String value = (String) hashMap.get(key);
            System.out.println(key + "....." + value);
        }
    }
}

方式2:同时获取key和value

Set<Map.Entry<K,V>> entrySet() — 获取Map中所有的键值对对象,放到set集合中
1.我们只需要获取到每个键值对的条目就行了
2.拿到条目,就能拿到条目上的key和value
3.记录key和value的条目, Map中的静态接口 — Map.Entry

Map.Entry中有两个方法
getKey() 获取key
getValue() 获取value

Set<Map.Entry<Integer, Object>> set1 = hashMap.entrySet();
        for (Map.Entry<Integer, Object> integerObjectEntry : set1) {
            Integer key = integerObjectEntry.getKey();
            String value = (String) integerObjectEntry.getValue();
            System.out.println(key + "...." + value);
        }

HashMap存储自定义对象

1.key存储自定义对象,value类型随意
2.需要key重写hashCode和equals方法
相关代码

public class Person {
    private String name;
    private int age;

    public Person() {
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && Objects.equals(name, person.name);
    }
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

public class test03 {
    public static void main(String[] args) {
        HashMap<Person, String> hashMap = new HashMap<>();
        hashMap.put(new Person("李云龙",18),"独立团");
        hashMap.put(new Person("孔捷",26),"新一团");
        hashMap.put(new Person("丁伟",26),"新二团");

        System.out.println(hashMap);
    }
}

Map的练习

需求:用Map集合统计字符串中每一个字符出现的次数
步骤
1.创建Scanner对象,调用next方法录入字符串
2.创建HashMap集合,key为String用于存储字符串,value作为Integer用于存储字符对应的个数
3.遍历字符串,判断,集合中有没有该字符
4.如果没有,将该字符以及对用的1存到Map集合中
5.如果有,根据该字符获取对用的value,对value进行加一
6.将该字符以及对用的value值存进去
7.输出

public class test03 {
    public static void main(String[] args) {
        System.out.println("请输入字符串");
        final Scanner scanner = new Scanner(System.in);
        String data = scanner.next();
        final HashMap<String, Integer> hashMap = new HashMap<>();
        char[] chars = data.toCharArray();
        for (char aChar : chars) {
            String achar = aChar + "";
            if (!hashMap.containsKey(achar)){
                hashMap.put(achar,1);
            }else {
                int value = hashMap.get(achar);
                value ++;
                hashMap.put(achar,value);
            }
        }
        System.out.println(hashMap);
    }
}

LinkedHashMap

概述 LinkedHashMap extends HashMap
特点:
a.有序
b.无索引
c.key唯一,value可重复
d.线程不安全
数据结构
哈希表+双向链表
用法:和HashMap一样

public class test04 {
    public static void main(String[] args) {
        final LinkedHashMap<String, String> hashMap = new LinkedHashMap<>();
        hashMap.put("001","李云龙");
        hashMap.put("002","丁伟");
        hashMap.put("003","孔捷");
        System.out.println(hashMap);
        //使用keyset方式遍历
        final Set<String> set = hashMap.keySet();
        for (String s : set) {
            final String s1 = hashMap.get(s);
            System.out.println(s+"...."+s1);
        }
        //使用entrySet方式遍历
        final Set<Map.Entry<String, String>> entries = hashMap.entrySet();
        for (Map.Entry<String, String> entry : entries) {
            System.out.println(entry.getKey()+ "...." +entry.getValue());
        }
    }
}

TreeSet

1.概述:ThreeSet是Set接口的实现类
2.特点:
a.可以对元素进行排序
b.元素唯一
c.无索引
d.线程不安全
3.数据结构
红黑树
4.方法 和HashSet一样

构造
TreeSet() — 对元素进行自然排序 ---- ASCII
TreeSet(Comparator<? suoer E> comparator) ----------- 按照指定规则进行排序

相关练习代码

public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    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;
    }
}
import java.util.Comparator;
import java.util.TreeSet;

public class test05 {
    public static void main(String[] args) {
        final TreeSet<String> treeSet = new TreeSet<>();
        treeSet.add("d");
        treeSet.add("a");
        treeSet.add("v");
        treeSet.add("c");
        treeSet.add("e");
        System.out.println(treeSet);
        System.out.println("=================");
        final TreeSet<Person> people = new TreeSet<>(new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge() - o2.getAge();
            }
        });
        people.add(new Person("李云龙",30));
        people.add(new Person("丁伟",21));
        people.add(new Person("孔捷",42));
        System.out.println(people);
    }
}

TreeMap

1.概述:TreeMap是Map接口的实现类
2.特点:
a.可以对key进行排序
b.无索引
c.线程不安全
3.数据结构:
红黑树
4.方法:
和HashMao一样

1.构造:
TreeMap() -> 按照自然顺序对key进行排序
TreeMap(Comparator<? super K> comparator)-> 按照指定规则对key进行排序

public class test06 {
    public static void main(String[] args) {
        final TreeMap<String, String> treeMap = new TreeMap<>();
        treeMap.put("a","宝儿姐");
        treeMap.put("b","张之维");
        treeMap.put("c","王也");
        treeMap.put("e","张楚岚");
        System.out.println(treeMap);
        System.out.println("====================");
        final TreeMap<Person, String> treeMap1 = new TreeMap<>(new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge() - o2.getAge();
            }
        });
        treeMap1.put(new Person("李云龙",32),"独立团");
        treeMap1.put(new Person("丁伟",42),"新一团");
        treeMap1.put(new Person("孔捷",33),"新二团");
        System.out.println(treeMap1);
    }
}

HashTable和Vector集合

HashTable集合

1.概述:是Map的实现类
2.特点:
a.无序
b.key唯一,value可重复
c.无索引
d.线程安全
3.数据结构
哈希表
4.用法
和HashMap一样

public class test07 {
    public static void main(String[] args) {
        final Hashtable<String, String> hashtable = new Hashtable<>();
        hashtable.put("老天师","张之维");
        hashtable.put("不要碧莲","张楚岚");
        hashtable.put("土豪道士","王也");
        System.out.println(hashtable);
    }
}

Vector集合

1.概述 是Collection的实现类
2.特点
a.有序
b.有索引
c.元素可重复
d.线程安全
3.数据结构
数组
4.用法 和ArrayList一样
5.底层分析:
a.Vector ---- new底层会直接产生一个长度为10 的空数组
b.数组扩容 Arrays.copyof 扩容两倍

public class test08 {
    public static void main(String[] args) {
        final Vector<String> vector = new Vector<>();
        vector.add("李云龙");
        vector.add("丁伟");
        vector.add("孔捷");
        System.out.println("vector = " + vector);
    }
}

HashMap和Hashtable的区别
1.相同点
key唯一,无索引,元素无序,底层都是哈希表
2.不同点
HashMap线程不安全,允许有null键null值
Hashtable线程安全,不允许有null键null值

Properties集合(属性值)

1.概述:Properties是Hashtable的子类
2.特点
a.无序
b.key唯一,value可重复
c.无索引
d.线程安全
e.Properties的key的value类型默认是String
f.不允许有null键null值
3.数据结构
哈希表
4.用法:
可以使用HashMap的方法
5.特有方法
Object setProperty(String key, String value) -> 存储键值对
String getProperty(String key) -> 根据key获取value
Set stringPropertyNames() -> 获取所有的key,存放到Set集合中
void load(InputStream inStream) -> 将流中的数据信息加载到Properties集合中

public class test01 {
    public static void main(String[] args) {
        final Properties properties = new Properties();
        //将键值对存入集合
        properties.setProperty("username","root");
        properties.setProperty("password","1234");
        System.out.println("properties = " + properties);
        //根据key获取相应的value
        System.out.println(properties.getProperty("username"));
        //获取所有的key,存放到set集合中和keyset方法效果一致
        final Set<String> set = properties.stringPropertyNames();
        for (String s : set) {
            System.out.println(properties.getProperty(s)+"...."+s);
        }
    }
}

List嵌套Map

需求:
一班有四名同学。学号和姓名分别为:
1=张楚岚,2=冯宝宝,3=王也,4=诸葛青
二班有三名同学,分别为:
1=张之维,2=张灵玉 3=夏禾
将同学的信息以键值对形式存入到2个Map集合中,再将2个map集合存储到list集合中

public class test02 {
    public static void main(String[] args) {
        final HashMap<Integer, String> hashMap = new HashMap<>();
        final HashMap<Integer, String> hashMap1 = new HashMap<>();
        hashMap.put(1,"张楚岚");
        hashMap.put(2,"冯宝宝");
        hashMap.put(3,"王也");
        hashMap.put(4,"诸葛青");
        hashMap1.put(1,"张之维");
        hashMap1.put(2,"张灵玉");
        hashMap1.put(3,"夏禾");
        final ArrayList<HashMap<Integer,String>> list = new ArrayList<>();
        list.add(hashMap);
        list.add(hashMap1);
        //遍历列表
        for (HashMap<Integer, String> integerStringHashMap : list) {
            final Set<Map.Entry<Integer, String>> entries = integerStringHashMap.entrySet();
            for (Map.Entry<Integer, String> entry : entries) {
                System.out.println(entry.getKey()+"..."+entry.getValue());
            }
        }
    }
}

Map嵌套map

javaSE集合存储的是学号 键,值学生姓名
1 张三
2 李四
javaEE 结合存储的是学号 键,值学生姓名
1 王五
2 赵六

public class test03 {
    public static void main(String[] args) {
        final HashMap<Integer, String> hashMap = new HashMap<>();
        final HashMap<Integer, String> hashMap1 = new HashMap<>();
        hashMap.put(1,"张三");
        hashMap.put(2,"李四");
        hashMap1.put(1,"王五");
        hashMap1.put(2,"田六");
        final HashMap<HashMap<Integer,String>, String> map = new HashMap<>();
        map.put(hashMap,"javaSE");
        map.put(hashMap1,"javaEE");
        //遍历大map
        final Set<Map.Entry<HashMap<Integer, String>, String>> entries = map.entrySet();
        for (Map.Entry<HashMap<Integer, String>, String> entry : entries) {
            System.out.println(entry.getKey()+"...."+entry.getValue());
        }
    }
}

哈希表结构存储过程

学习大数据,所必需的java基础(6),学习,大数据,java
要知道的点
a.在不指定长度时,哈希表中的数组默认长度为16,HashMap创建出来,一开始没有床架长度为16的数组
b.在第一次put的时候,底层会创建出来长度为16的数组
c.哈希表中有一个数据加【加载因子】---- 默认为0.75(加载因子)---- 代表当元素存储到百分之七十五的时候要扩容了—0–2倍
d.如果元素的哈希值出现相同,内容不一样时,就会在同一个索引上以链表的形式存储,当链表长度达到8,并且当前数组长度>64时,链表就会改成使用红黑树存储
e.加入红黑树目的:查询快
面试时可能会问到的变量
default_initial_capacity:HashMap默认容量 16
defaul_load_factor:HashMap默认加载因子 0.75f
threshold 扩充的临界值 等于 容量8*0.75 =12 第一次扩容
threeify_threshold: 链表长度默认值,转为红黑树:8
min_treeify_capacity: 链表被树化时最小的数组容量 64

HashMap无参数构造方法的分析

HashMap中的静态成员变量

static final float DEFAULT_LOAD_FACTOR = 0.75f;
public HashMap() {
    this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}

解析:使用无参数构造方法创建HashMap对象,将加载因子设置成默认的加载因子,loadfactor=0.75

HashMap有参数的构造方法的分析

解析 如果带有参数构造方法,传递哈希表的初始化容量和加载因子

HashMap(int initialCapacity, float loadFactor) ->创建Map集合的时候指定底层数组长度以及加载因子
    
public HashMap(int initialCapacity, float loadFactor) {
//如果初始化容量小于0,直接抛出异常
    if (initialCapacity < 0)
    	throw new IllegalArgumentException("Illegal initial capacity: " +
    initialCapacity);
//如果初始化容量大于最大容量,初始化容量直接等于最大容量
    if (initialCapacity > MAXIMUM_CAPACITY)
    	initialCapacity = MAXIMUM_CAPACITY;
//如果loadFactor(加载因子)小于等于0,直接抛出异常
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
    	throw new IllegalArgumentException("Illegal load factor: " +
    loadFactor);
    this.loadFactor = loadFactor;
    this.threshold = tableSizeFor(initialCapacity);//10

tableSizeFor方法分析

tableSizeFor(initCapacity)方法计算哈希表的初始化容量
注意 哈希表是进行计算得出的容量,而初始化容量不直接等于我们传递的参数。
8 4 2 1规则—无论指定了多少容量,最终经过tableSizeFor这个方法计算以后,都会遵守8421规则去初始化列表容量
解析:该方法对我们传递的初始化容量进行位移运算,位移的结果是8421码
例如传递2,结果还是2,传递的是4,结果还是4
传递3,结果传递4,传递5,结果是8,传递20,结果是32

Node内部类的分析

哈希表是采用数组加链表的实现方法
HashMap中的内部类Node非常重要,证明HashSet是一个单向链表

 static class Node<K,V> implements Map.Entry<K,V> {
     final int hash;
     final K key;
     V value;
     Node<K,V> next;
 Node(int hash, K key, V value, Node<K,V> next) {
     this.hash = hash;
     this.key = key;
     this.value = value;
     this.next = next;
}

解析:内部类Node中具有四个成员变量
hash 对象的哈希值
key 作为键的对象
value 作为值的对象
next,下一个节点对象

存储元素的put方法源码

public V put(K key, V value) {
	return putVal(hash(key), key, value, false, true);
}

解析:put方法中调用putVal方法,putVal方法中调用hash方法
hash(key)方法;传递要存储的元素,获取对象的哈希值
putVal方法:传递对象哈希值和要存储的对象key

putVal方法源码

Node<K,V>[] tab; Node<K,V> p; int n, i;
	if ((tab = table) == null || (n = tab.length) == 0)
		n = (tab = resize()).length;

解析,方法中进行Node对象数组的判断,如果数组是null或者长度等于0,那么就会调用resize()方法进行数组的扩充

resize方法的扩充计算

if (oldCap > 0) {
     if (oldCap >= MAXIMUM_CAPACITY) {
         threshold = Integer.MAX_VALUE;
         return oldTab;
     }
     else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
              oldCap >= DEFAULT_INITIAL_CAPACITY)
         newThr = oldThr << 1; // double threshold
}

解析:计算结果,新的数组容量 = 原始数组容量 <<1,也就是乘以2

确定元素存储的索引

if ((p = tab[i = (n - 1) & hash]) == null)
	 tab[i] = newNode(hash, key, value, null);

解析:i = (数组长度-1) & 对象的哈希值,会得到一个索引,然后在此索引下tab[i],创建链表对象。不同的哈希值的对象,也是有可能存储在同一个数组索引下

遇到重复哈希值的对象

 Node<K,V> e; K k;
 if (p.hash == hash &&
 	((k = p.key) == key || (key != null && key.equals(k))))
		 e = p;

解析 如果对象的哈希值相同,对象的equals方法返回true,判断为一个对象,进行覆盖操作

else {
     for (int binCount = 0; ; ++binCount) {
     	if ((e = p.next) == null) {
     		p.next = newNode(hash, key, value, null);
     	if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
     		treeifyBin(tab, hash);
     	break;
 }

解析:如果对象哈希值相同吗,但是对象的equals方法返回false,将对此链表进行遍历
当链表没有下一个节点的时候,创建下一个节点存储对象文章来源地址https://www.toymoban.com/news/detail-837555.html

到了这里,关于学习大数据,所必需的java基础(6)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • JAVA基础学习笔记-day14-数据结构与集合源码2

    博文主要是自己学习JAVA基础中的笔记,供自己以后复习使用,参考的主要教程是B站的 尚硅谷宋红康2023大数据教程 君以此始,亦必以终。—左丘明《左传·宣公十二年》 7.1 List接口特点 List集合所有的元素是以一种 线性方式 进行存储的,例如,存元素的顺序是11、22、33。那

    2024年01月18日
    浏览(60)
  • 01 java 学习 数据类型、基础语法、封装、继承、多态、接口、泛型、异常等

    目录 环境搭建和基础知识  什么是JRE: 什么是JDK: 基础数据类型  分支选择if else switch和c一毛一样 for和while循环还有数组基本和c一样 封装 函数调用、传参、命名规范、数组新命名规范 java输入Scanner scanner = new Scanner(System.in); 类的创建和使用以及封装修饰符  构造方法:含义、

    2024年02月11日
    浏览(41)
  • Java 学习路线:基础知识、数据类型、条件语句、函数、循环、异常处理、数据结构、面向对象编程、包、文件和 API

    Java 是一种由 Sun Microsystems 于 1995 年首次发布的编程语言和计算平台。Java 是一种通用的、基于类的、面向对象的编程语言,旨在减少实现依赖性。它是一个应用程序开发的计算平台。Java 快速、安全、可靠,因此在笔记本电脑、数据中心、游戏机、科学超级计算机、手机等领

    2024年03月24日
    浏览(87)
  • AI是时代必需还是贩卖焦虑

    1956年,美国汉诺斯小镇的达特矛斯学院,约翰·麦卡锡、马文·闵斯基、克劳德·香农等学者聚在一起,共同讨论着机器模拟智能的一系列问题。他们讨论了很久,始终没有达成共识,却为讨论内容起了一个名字:人工智能。自此,人工智能(AI,Artificial Intelligence)开始出现

    2024年02月03日
    浏览(85)
  • 思科路由器配置时的必需命令介绍

      一、在路由器上配置一个登录帐户,为用户名使用一个秘密口令,而不仅有一个常规口令。它用MD5加密方法来加密口令,并且大大提高了安全性。 Router(config)# username root secret My$Password Router(config-line)# login local Router(config)# line aux 0 Router(config-line)# login local Router(config)# line v

    2024年02月05日
    浏览(41)
  • 光纤入户的必需性及FTTH的发展现状

    FTTH的概念 FTTH(Fiber To The Home ),顾名思义就是一根光纤直接到家庭。具体说,FTTH是指将光网络单元(ONU)安装在住家用户或企业用户处,是光接入系列中除FTTD(光纤到桌面)外最靠近用户的光接入网应用类型。FTTH的显著技术特点是不但提供更大的带宽,而且增强了网络对数据格

    2024年02月07日
    浏览(87)
  • Java基础学习笔记-5

    Java编程语言是一门广泛应用于软件开发领域的高级编程语言。它的强大特性和跨平台性使其成为许多开发者的首选语言。本文将介绍一些Java编程的关键概念,包括函数重载、可变参数、值传递、递归等,这些概念是Java编程的基础,对于理解和掌握Java语言至关重要。 Java基础

    2024年02月09日
    浏览(30)
  • Java基础学习笔记-1

    Java 是一门强大而广泛应用的编程语言,它的灵活性和跨平台特性使其成为许多开发者的首选。无论您是刚刚入门编程,还是已经有一些编程经验,掌握 Java 的基础知识都是构建更复杂程序的关键。 本学习笔记旨在帮助您深入了解 Java 编程语言的基础概念。我们将从变量和数

    2024年02月09日
    浏览(35)
  • Java 基础语法学习笔记

    目录 一、Java语言概述 1.1 Java 的出现 1.2 Java的主要特性 1.3 Java语言的特点 1.4 Java语言的核心机制 1.5 Java语言的环境搭建  二、第一个Java程序 2.1 需要注意的问题 2.2 注释(comment)  2.3 注意点: 2.4 Java API 的文档 2.5 第一个 Java 程序 三、Java基本语法 3.1  Java中的名称命名规范  

    2024年02月06日
    浏览(40)
  • Java基础学习大全(一)

    基础学习 一、基本了解: 1、JVM、JRE和JDK的区别:     JVM(Java Virtual Machine):java虚拟机,用于保证java的跨平台的特性。                   java语言是跨平台,jvm不是跨平台的。     JRE(Java Runtime Environment):java的运行环境,包括jvm+java的核心类库。         JDK(Java Developme

    2024年02月12日
    浏览(31)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包