Java集合类
Java集合类 (1)
1.Map (3)
1.1.HashMap (3)
1.1.1.底层实现 (3)
1.1.2.特点 (3)
1.1.3.源码分析 (4)
1.1.4.多线程可能出现的问题 (5)
1.2.ConcurrentHashMap (6)
1.2.1.底层实现 (6)
1.2.2.源码分析 (7)
1.3.HashTable (9)
1.3.1.HashTable是线程安全的，因为所有方法上都加了synchronized关键
字。9
1.3.2.HashTable的key和value都不可以为null。 (9)
1.3.3.扩容时，capacity=2*capacity+1 (9)
1.3.4.数组默认大小为11 (9)
1.3.5.查找下标时，没有使用hash&length-1，而是直接进行计算的 (9)
1.4.TreeMap (9)
1.4.1.底层实现为红黑树 (9)
1.4.
2.TreeMap是一个有序的key-value集合，基于红黑树实现。该映射根据
其键的自然顺序进行排序，或者根据创建时提供的Comparator进行排序 (10)
1.4.3.接口实现 (10)
1.4.4.Entry (11)
1.5.LinkedHashMap (11)
1.5.1.底层是数组+链表+红黑树+双向链表 (11)
1.5.2.维护链表顺序和访问顺序 (11)
1.5.3.LinkedHashMap 可以通过构造参数 accessOrder 来指定双向链表是否在
元素被访问后改变其在双向链表中的位置。 (11)
1.5.4.当accessOrder为true时，get方法和put方法都会调用recordAccess
方法使得最近使用的Entry移到双向链表的末尾；当accessOrder为默认值
false时，recordAccess方法什么也不会做。 (11)
1.5.5.LRU实现 (11)
2.Collection (11)
2.1.List (12)
2.1.1.ArrayList (12)
2.1.2.LinkedList (13)
2.1.3.CopyOnWriteArrayList (13)
2.2.Set (14)
2.2.1.HashSet (14)
2.2.2.TreeSet (14)
2.2.3.LinkedHashSet (15)
1.Map
1.1.HashMap
1.1.1.底层实现
1.7 数组+链表
数组的优点是访问速度快，但是插入删除操作慢
因为数组在内存中是连续存放的，因此存取很快
链表的优点是插入删除速度快，但是访问速度慢
由于链表不是连续存放的，因此插入删除时，只需要修改前后指针的指
向即可，不需要移动元素位置
1.8 数组+链表+红黑树
拉链法由头插法改为了尾插法
因为头插法在多线程的时候可能会导致死循环
链表长度大于8的时候转化为红黑树
红黑树的时间复杂度为logn,线性表查找的平均时间复杂度为n/2,因此在
链表长度为8时进行转化效率最高
红黑树的转化也是比较消耗性能的
链表个数超过8则链表转换成树结构，链表个数小于8则树结构转换成
链表
1.1.
2.特点
存取的时间复杂度为O(1)
1.1.3.源码分析
put()
1.判断key是否为null，如果为null，调用putlForNullKey，将key插入到
数组下标为0的位置
2.调用hash()方法计算key的hashcode，得到hash值
3.调用indexFor()方法进行取模运算，得到元素的下标位置
1.indexFor方法为：h&(length - 1)
2.使用与运算，计算速度更快，因为二进制运算比十进制运算效率更高
(十进制运算还需要将二进制转化为十进制)
3.length之所以要设定为2次幂，就是为了这个indexFor方法服务
4.可以让散列更加均匀，length-1的最后一位为1，因此进行与运算时，
可以散列到奇数和偶数的下标位置，如果对length直接取模，由于
length为2次幂，所以最后一位一定为0，所以与运算的结果一定是偶
数，这也就导致奇数下标的位置不能被散列到。
4.依次和该下标位置上的链表中的node节点比较key是否相等
e.hash == hash && ((k = e.key) == key || key.equals(k))
首先判断e.hash==hash是因为不同的key值也可能被散列到同一个位
置，因此首先判断hash值，如果不相等则两个key肯定不等
如果相等，再通过==和equals比较是否相等，之所以要先判断hash值是否相等，是因为equal()很耗性能，因此先判断hash值能够提高效率
重写了hashcode()方法就必须重写equals方法
5.如果相等，更新value值，如果不相等，使用头插法(1.7)/尾插法(1.8)将
entry(1.7)/Node(1.8)插入到链表中
get()
和put()方法类似，获取到桶的下标，再在链表上查找key值，再获取key 对应的value值
resize()
当hashmap中的元素个数超过数组大小*loadFactor时，就会进行数组扩容
扩容时，令 capacity 为原来的两倍。
1.7时，需要new 一个新数组，并对旧数组上的所有元素进行indexFor()操
作确定下标地址,这一步很费时，1.8时只需判断hash值的左边新增的那一位是否为1，即可判断此节点是留在原地lo还是移动去高位hi,如果为1，则移动去高位，否则不变
1.7时，扩容的时候可能出现死循环，1.8没有这个问题
构造方法
在第一次put()的时候，数组才初始化
数组的长度为大于指定值的最小二次幂
数组默认大小为16
1.1.4.多线程可能出现的问题
1.扩容时可能出现死循环
2.put的时候可能被失效/覆盖
线程A,B同时调用addEntry方法，同时获取到了相同的头节点，然后A写入新的头结点之后，B也写入新的头结点，那B的写入操作就会覆盖A的写入操作造成A的写入操作丢失。
3.修改的时候可能被覆盖
线程A,B先后修改同一key值的value，会导致覆盖
4.put非null元素后get出来的却是null
扩容时调用的transfer方法，在获取数组的每个头节点的时候，在将e=头节点之后，都会将头节点置空，此时get可能导致获取到的值为0
1.2.ConcurrentHashMap
1.2.1.底层实现
1.7 segment数组+HashEntry数组(数组+链表)
chm由一个segment数组组成
segment
每个segment元素包含一个HashEntry数组，每个HashEntry包含一个链表
HashEntry大部分成员变量都为final
final k key
volatile V value
final int hash
final HashEntry
1.8 数组+链表+红黑树
1.2.2.源码分析
put()
基本流程
1.7 通过两次hash确定
第一次Hash定位到Segment
通过segmentFor()函数进行,计算方式也和indexFor()相同
SegmentMask
ssize-1
SegmentShift
32-sshift
ssize
是大于ConcurrentLevel的最小二次幂
第二次Hash定位到元素所在的链表的头部
定位方法和HashMap中的indexFor()相同
通过segment.lock加锁
1.8通过两次hash确定
通过CAS+synchronized加锁
1.如果没有hash冲突就直接通过CAS插入
2.如果有hash冲突或者CAS操作失败，说明存在并发情况，使用
synchronized加锁
3.如果插入成功就调用addCount（）方法统计size，并且检查是否需要
扩容
源码分析
1.ensureSegment
1.判断是否被其他线程初始化，这里使用了getObjectVolatile()方法
2.使用segment[0]的属性来初始化其他槽
3.使用while()循环，内部使用CAS操作，尝试初始化槽
2.segment.put()
get()
get不需要加锁，因为HashEntry的value值设定为了volatile
如果get()到的是null值，则可能这个key，value对正在put的过程中，如果出现这种情况，那么就通过lock加锁来保证取出的value是完整的
resize()
构造函数
先根据ConcurrentLevel构造出Segment数组
Segment数组大小是不大于concurrentLevel的最大的2的指数
每个Segment中的HashEntry数组的大小都是大于指定大小的最小二次幂
每个hashEntry的大小为大于initialCapacity/concurrentLevel的最小二次幂
初始参数
initialCapacity(每个HashEntry的长度)
loadFactor：扩容因子
concurrencyLevel：并发度，指Segment数组的长度
remove
在定位到待删除元素的位置以后，程序就将待删除元素前面的那一些元素全部复制一遍，然后再一个一个重新接到链表上去。尾结点指向e的下一个结点。e后面的结点不需要复制，它们可以重用。
因为HashEntry中的next是final，所以只能先把待删除之前的元素复制了再删除
size
size操作就是遍历了两次Segment，每次记录Segment的modCount值，然后将两次的modCount进行比较，如果相同，则表示期间没有发生过写入操作，就将原先遍历的结果返回，如果不相同，就需要将所有的
Segment都锁住，然后一个一个遍历了，
1.3.HashTable
1.3.1. HashTable是线程安全的，因为所有方法上都加了synchronized关键字。
1.3.
2.HashTable的key和value都不可以为null。
1.3.3.扩容时，capacity=2*capacity+1
1.3.4.数组默认大小为11
1.3.5.查找下标时，没有使用hash&length-1，而是直接进行计算的
1.4.TreeMap
1.4.1.底层实现为红黑树
能够保证树总是平衡的，如果插入删除导致树不平衡，会自动进行调整
变色
左旋
右旋
查找的平均时间复杂度为O(logN)
主要规则
1.每个节点或者是黑色，或者是红色。
2.根节点是黑色
3.叶子节点为黑色
4.如果一个节点是红色的，则它的子节点必须是黑色的
5.从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点。
1.4.
2.TreeMap是一个有序的key-value集合，基于红黑树实现。该映射根据其键的自然顺序进行排序，或者根据创建时提供的Comparator进行排序
1.4.3.接口实现
NavigableMap
是SortedMap接口的子接口，在其基础上扩展了一些方法，例如
floorEntry，lowEntry,ceilingEntry等
为了防止外部修改Entry，使用了ExportEntry修饰floorEntry等方法
SortedMap
定义按照key排序的Map结构，能够令Map按照key的自然顺序或者构
造器顺序进行排序。
1.4.4.Entry
包含了left，right，parent节点
1.5.LinkedHashMap
1.5.1.底层是数组+链表+红黑树+双向链表
同时使用一个额外的双向链表来维护链表的访问顺序
1.5.
2.维护链表顺序和访问顺序
Node节点额外增加了before和after指针，用于维护链表的访问顺序
next指针用来维护链表顺序
1.5.3.LinkedHashMap 可以通过构造参数 accessOrder 来指定双向链表是否在元
素被访问后改变其在双向链表中的位置。
1.5.4.当accessOrder为true时，get方法和put方法都会调用recordAccess方
法使得最近使用的Entry移到双向链表的末尾；当accessOrder为默认值false 时，recordAccess方法什么也不会做。
1.5.5.LRU实现
插入数据后对调用afterNodeInsertion，afterNodeInsertion()方法中会调用
removeEldestEntry，如果removeEldestEntry(first)返回true，按照LRU策
略，那么会删除头节点(注意这里删除的是头节点！！！所以每次访问元素或者插入元素之后都要将该元素放到链表末尾)。这个也是实现LRU的关键
点！！！！！
2.Collection
2.1.List
2.1.1.ArrayList
底层实现
动态数组
能够实现随机存取
实现了RandomAccess接口
fail-fast机制
在使用迭代器遍历list时，如果modCount和expectedCount不匹配，就会直接抛出异常
modCount在AbstractList中定义
使用迭代器自带的remove()函数的时候，如果删除了list中元素，不会出现fail-fast,因为迭代器会调整modCount和expectedCount值
自定义了序列化方法
因为arrayList的底层数组中，可能存在值为null的元素，序列化这些元素是没有意义的，因此自定义了序列化方法，只序列化数组中非null的元素
通过readObject()和writeObject()方法实现
源码实现
扩容：capacity=1.5*capacity
通过Arrays.copyOf()
System.copyOf()
每次扩容的时候，都会传入一个minCapacity,即扩容之后的数组长度，对于add方法，是原size+1,对于addAll方法，是size+newSize,如果原数组长度*1.5仍不能存放所需的元素，那么就会直接令数组长度为
minCapacity
ArrayList是插入前扩容,扩容逻辑为 ensureCapacityInternal()---
>ensureExplicitCapacity()---->grow()
2.1.2.LinkedList
底层实现
双向链表
常用api
add
offer
remove
适合插入删除多的场合
2.1.
3.CopyOnWriteArrayList
和ArrayList基本一模一样，但它是线程安全的
任何对array在结构上有所改变的操作（add、remove、clear等），CopyOnWriterArrayList都会copy现有的数据，再在copy的数据上修改，这样就不会影响COWIterator中的数据了，不会抛ConcurrentModificationException异常(对set,add没有作用，因为set,add本来就要加锁)，修改完成之后改变原有数据的引用即可。
读操作不加锁，写操作加锁，在进行add,set等操作时，会通过ReentrantLock进行加锁
适合多读少写的场景
缺点
1.复制的数组会消耗内存
2.不能读取实时性的数据
3.会产生大量的对象
2.2.Set
2.2.1.HashSet
底层是数组+链表+红黑树
基于HashMap实现
所有元素的value值都是一个static final Object
hashSet的存储是无序的
因为HashSet是根据对象的hashCode，进行计算后存储的
最后一个构造函数，为包访问权限是不对外公开，主要是为了支持
LinkedHashSet
HashSet(int initialCapacity, float loadFactor, boolean dummy)
多了一个dummy变量
2.2.2.TreeSet
基于TreeMap实现
add()时，value值都是一个static final Object对象,因此当key相等时就会覆盖，也实现了没有重复元素的问题
2.2.
3.LinkedHashSet
基于LinkHashMap实现
史上最全Java基础知识点归纳 写这篇文章的目的是想总结一下自己这么多年来使用Java的一些心得体会，主要是和一些Java基础知识点相关的，所以也希望能分享给刚刚入门的Java 程序员和打算入Java开发这个行当的准新手们，希望可以给大家一些经验，能让大家更好学习和使用Java。 这次介绍的主要内容是和J2SE相关的部分，另外，会在以后再介绍些J2EE 相关的、和Java中各个框架相关的内容。 经过这么多年的Java开发，以及结合平时面试Java开发者的一些经验，我觉得对于J2SE方面主要就是要掌握以下的一些内容。 1.JVM相关(包括了各个版本的特性) 对于刚刚接触Java的人来说，JVM相关的知识不一定需要理解很深，对此里面的概念有一些简单的了解即可。不过对于一个有着3年以上Java经验的资
深开发者来说，不会JVM几乎是不可接受的。 JVM作为Java运行的基础，很难相信对于JVM一点都不了解的人可以把Java语言吃得很透。我在面试有超过3年Java经验的开发者的时候，JVM几乎就是一个必问的问题了。当然JVM不是唯一决定技术能力好坏的面试问题，但是可以佐证Java开发能力的高低。 在JVM这个大类中，我认为需要掌握的知识有： JVM内存模型和结构 GC原理，性能调优 调优：Thread Dump，分析内存结构 class二进制字节码结构，class loader体系，class加载过程，实例创建过程 方法执行过程 Java各个大版本更新提供的新特性(需要简单了解) 2.Java的运行（基础必备） 这条可能出看很简单，Java程序的运行谁不会呢？不过很多时候，我们只是单纯通过IDE去执行Java程序，底层IDE又是如何执行Java程序呢？很多人并不了解。
https://www.doczj.com/doc/024046724.html,ng.Object 类，是所有类的根父类！ 2.Object类仅有一个空参的构造器public Object(){ } 3.关于方法： ①equals(Object obj) public boolean equals(Object obj) { return (this == obj); } // == // 1.基本数据类型：根据基本数据类型的值判断是否相等。相等返回true，反之返回false // 注：两端数据类型可以不同，在不同的情况下，也可以返回true。 // 2.引用数据类型：比较引用类型变量的地址值是否相等。 //equals(): >①只能处理引用类型变量②在Object类，发现equals()仍然比较的两个引用变量的地址值是否相等 >像String 包装类File类Date类这些重写Object类的equals()方法，比较是两个对象的 //"实体内容"是否完全相同。 >若我们自定义一个类，希望比较两个对象的属性值都相同的情况下返回true的话，就需要重写Object类的 equals(Object obj)方法 ②toString()方法
当我们输出一个对象的引用时，会调用toString()方法。 1.public String toString() { return getClass().getName() + "@" + Integer.toHexString(hashCode()); } 当我们没有重写Object类的toString()方法时，打印的就是对象所在的类，以及对象实体在堆空间的位置 2.一般我们需要重写Object类的toString()方法，将此对象的各个属性值返回。 3.像String类、Date、File类、包装类都重写了toString()方法。 1. String类：不可变的字符序列（如：String str = "atguigu"; str += "javaEE"） 1.关注于String常用的方法！ 2.String类与基本数据类型、包装类；与字符数组、字节数组； * 1.字符串与基本数据类型、包装类之间转换 * ①字符串--->基本数据类型、包装类:调用相应的包装类的parseXxx(String str); * ①基本数据类型、包装类--->字符串:调用字符串的重载的valueOf()方法 *
Java集合类 Java集合类 (1) 1.Map (3) 1.1.HashMap (3) 1.1.1.底层实现 (3) 1.1.2.特点 (3) 1.1.3.源码分析 (4) 1.1.4.多线程可能出现的问题 (5) 1.2.ConcurrentHashMap (6) 1.2.1.底层实现 (6) 1.2.2.源码分析 (7) 1.3.HashTable (9) 1.3.1.HashTable是线程安全的，因为所有方法上都加了synchronized关键 字。9 1.3.2.HashTable的key和value都不可以为null。 (9) 1.3.3.扩容时，capacity=2*capacity+1 (9) 1.3.4.数组默认大小为11 (9) 1.3.5.查找下标时，没有使用hash&length-1，而是直接进行计算的 (9) 1.4.TreeMap (9) 1.4.1.底层实现为红黑树 (9) 1.4. 2.TreeMap是一个有序的key-value集合，基于红黑树实现。该映射根据 其键的自然顺序进行排序，或者根据创建时提供的Comparator进行排序 (10) 1.4.3.接口实现 (10) 1.4.4.Entry (11) 1.5.LinkedHashMap (11) 1.5.1.底层是数组+链表+红黑树+双向链表 (11) 1.5.2.维护链表顺序和访问顺序 (11) 1.5.3.LinkedHashMap 可以通过构造参数 accessOrder 来指定双向链表是否在 元素被访问后改变其在双向链表中的位置。 (11) 1.5.4.当accessOrder为true时，get方法和put方法都会调用recordAccess 方法使得最近使用的Entry移到双向链表的末尾；当accessOrder为默认值 false时，recordAccess方法什么也不会做。 (11) 1.5.5.LRU实现 (11) 2.Collection (11) 2.1.List (12) 2.1.1.ArrayList (12) 2.1.2.LinkedList (13) 2.1.3.CopyOnWriteArrayList (13) 2.2.Set (14) 2.2.1.HashSet (14)
Created by AIwen on 2017/5/14. java是面向对象的程序设计语言；类可被认为是一种自定义的数据类型，可以使用类来定义变量，所有使用类定义的变量都是引用变量，它们将会引用到类的对象。类用于描述客观世界里某一类对象的共同特征，而对象则是类的具体存在，java程序使用类的构造器来创建该类的对象。 java也支持面向对象的三大特征：封装、继承、和多态。java提供了private、protected、和public三个访问控制修饰符来实现良好的封装，提供了extends关键字让子类继承父类，子类继承父类就可以继承到父类的成员变量和和方法，如果访问控制允许，子类实例可以直接调用父类里定义的方法。继承是实现类复用的重要手段。使用继承关系来实现复用时，子类对象可以直接赋给父类变量，这个变量具有多态性。 面向对象的程序设计过程中有两个重要的概念：类（Class)和对象（object，也被称为实例，instance）。类可以包含三种最常见的成员：构造器、成员变量、和方法。 构造器用于构造该类的实例，java语言通过new关键字类调用构造器，从而返回该类的实例。构造器是一个类创建对象的根本途径，如果一个类没有构造器，这个类通常无法创建实例。因此java语言提供了一个功能：如果程序员没有为一个类编写构造器，则系统会为该类提供一个默认的构造器，这个构造器总是没有参数的。一旦程序员为一个类提供了构造器，系统将不再为该类提供构造器。 构造器用于对类实例进行初始化操作，构造器支持重载，如果多个重载的构造器里包含了相同的初始化代码，则可以把这些初始化代码放置在普通初始化块里完成，初始化块总在构造器执行之前被调用。静态初始化块代码用于初始化类，在类初始化阶段被执行。如果继承树里某一个类需要被初始化时，系统将会同时初始化该类的所有父类。 构造器修饰符：可以是public、protected、private其中之一，或者省略构造器名：构造器名必须和类名相同。 注意：构造器既不能定义返回值类型，也不能使用void声明构造器没有返回值。如果为构造器定义了返回值类型，或使用void声明构造器没有返回值，编译时不会出错，但java会把这个所谓的构造器当成方法来处理——它就不再是构造器。 实际上类的构造器是有返回值的，当使用new关键字来调用构造器时，构造器返回该类的实例，可以把这个类的实例当成构造器的返回值。因此构造器的返回值类型总是当前类，无须定义返回值类型。不要在构造器里显式的使用return来返回当前类的对象，因为构造器的返回值是隐式的。 java类名必须是由一个或多个有意义的单词连缀而成的，每个单词首字母大写，其他字母全部小写，单词与单词之间不要使用任何分隔符。 成员变量： 成员变量的修饰符：public、protected、private、static、final前三个只能出现一个再和后面的修饰符组合起来修饰成员变量，也可省略。 成员变量：由一个或者多个有意义的单词连缀而成，第一个单词首字母小写，后面每个单词首字母大写，其他字母全部小写，单词与单词之间不要使用任何分隔符。 类型：可以是java语言允许的任何数据类型，包括基本类型和引用类型。 成员方法： 方法修饰符：public、protected、private、static、final、abstract，前三个只能出现一个，static和final最多只能出现其中的一个，和abstract组合起来使用。也可省略。 返回值类型：可以是java语言的允许的任何数据类型，包括基本类型和引用类型。 方法名：和成员变量的方法命名规则相同，通常建议方法名以英文动词开头。 方法体里多条可执行语句之间有严格的执行顺序，排在方法体前面的语句总先执行，排在方法体后面的语句总是后执行。 static是一个特殊的关键字，它可用于修饰方法、成员变量等成员。static修饰的成员表明它属于这个类本身，而
目录 第一章 Java入门 (2) 第二章 Java基础 (5) 第三章条件转移 (16) 第四章循环语句 (22) 第五章方法 (28) 第六章数组 (35) 第七章面向对象 (44) 第八章异常 (65)
第一章Java入门 知识点汇总 1、JAVA 三大体系 ?Java SE：（J2SE，Java2 Platform Standard Edition，标准版），三个平台中最核心 的部分，包含Java最核心的类库。 ?JavaEE：（J2EE，Java 2 Platform, Enterprise Edition，企业版），开发、装 配、部署企业级应用，包含Servlet、JSP、 JavaBean、JDBC、EJB、Web Service等。 ?Java ME：（J2ME，Java 2 Platform Micro Edition，微型版），用于小型电子设备 上的软件开发。 2、JDK,JRE,JVM的作用及关系 作用 ★JVM：保证Java语言跨平台 ★JRE：Java程序的运行环境 ★JDK：Java程序的开发环境 关系 ★JDK：JRE+工具 ★JRE：JVM+类库 3、JDK环境变量配置 ?path环境变量：存放可执行文件的存 放路径，路径之间用逗号隔开 ?classpath环境变量：类的运行路径， JVM在运行时通过classpath加载需要 的类 4、重点掌握两个程序 ?javac.exe：Java编译器工具，可以将编 写好的Java文件（.java）编译成Java 字节码文件（.class）; ?java.exe：Java运行工具，启动Java虚 拟机进程，运行编译器生成的字节码 文件(.class) 5、一切程序运行的入口 public static void main（String args []）{ System.out.println(“Hello World!”); } 课堂笔记
数据库 oracle-->数据库管理系统-->SQL、PL/SQL-->Java(JDBC+SQL) DBA,数据库编程程序员 1.概念导论 1）什么是数据库 有组织和结构存储数据。可以存储 字符、字节、图形、图像等类型数据 DB(数据库):数据集合 DBMS(数据库管理系统)：对数据集合进行管理和操作的软件 --Oracle --DB2 --MySQL --SQLSERVER JDBC 1.什么是JDBC 全称Java DataBase Connection,Java数据库访问。 JDBC是Java访问数据库的一项技术 JDBC是SUN推出的Java访问数据库的一套标准。由一系列接口构成。 各个数据库厂商负责提供JDBC接口API的实现包。 开发者只需要掌握JDBC接口的使用,就可以实现对各种数据库的操作，不需要了解开发商的实现类。 XML 1、什么是xml(xtendsible markup language可扩 展的标记语言)? 1)定义 基于文本的通用的数据保存格式。 (1)通用的点的坐标 Point类point对象(x=10,y=20) a,序列化 b,数据库表 c,文件 ... (2)数据格式
HTML 知识准备 1、分层：表现层：UI界面（DOS界面、桌面类型、web类型） 业务层： 数据层：文件、Oracle数据库 2、Web类型的应用程序----B/S类型 打开Browser，输入URL，浏览器将请求发送到服务器 服务器得到请求，分析，返回响应 浏览器得到响应，解析（翻译），显示为页面 3、web学习阶段 客户端技术：HTML+CSS+Javascript---Web基础 服务器端技术：JSP、PHP、https://www.doczj.com/doc/024046724.html, 4、web基础的课程 HTML：页面的创建 CSS：页面的外观 JavaScript：页面的动态效果和交互行为--3 一：HTML概述 1、超文本标记语言：一种编写页面的纯文本的标记语言，文件以.html或者.htm为后缀，依靠浏览器运行显示----解释性的语言 2、标记：一些用<>括起来的内容，特殊的显示 3、主流浏览器：IE/Firefox/Chrome/ 4、浏览器兼容性：符合标准规范，具体问题 CSS 一：CSS概述 1、CSS：级联样式表（层叠样式表） 2、特征：为页面定义外观的语言，实现内容和表现的分离，多个样式可以合为一个，如果冲突，以优先级为准 二：基础语法 1、语法：属性名称:值;属性名称:值;比如--color:red; 2、如何应用 方式一（内联方式）：<元素style=""/>---将样式直接定义在元素的style属性里 方式二（内部样式表）：在页面的head里的style里定义样式 方式三（外部样式表）：定义一个单独的.css的文件（定义样式）；然后，在页面的head里用link引入---推荐方式 3、外部样式表的优点：实现内容和表现的分离，提高代码的可重用性和可维护性
一、单选题 1.对类：(B) public class Test( //...do something } 下面那个正确地定义了类Test的构造函数。 A)public void Test() () B)publicTest()(} C ) public static Test() (} D) publicTest(); 2.下面哪个函数是public void example()(...)的重载函数。(A) A)public void example( float f)(...) B)public int example() (...) C)public void example2()(...} D)public int example_overLoad ()(...) 3.下面的代码段中，执行之后i和j的值是_C_。 int i = 1; intj； j = i++； A)1, 1 B) 1,2 C) 2, 1 D) 2,2 4.以下for循环的执行次数是_B o for(int x=0,y=0;(y !=0)&&(x<4) ;x++); A)无限次B) 一次也不执行 C)执行4次D)执行3次 5.下面程序的输出结果是—C o public class People( String name; int id; public People( String str, int n )( name = str; id = n; } public String toString(){ return id + " ：” + name; } public String print()(
第一章初识java 一、java语言的历史 ●第一代java语言：Oak 二、java语言的现状 ?Java SE:主要用于桌面程序的开发。 ?Java EE:主要用于网页程序的开发。 ?Java ME:主要用于嵌入式系统程序的开发。（安卓）三、java语言的特点 ●跨平台（不同的操作系统都可运行） ●简单（没有直接使用指针） ●面向对象（世间万物皆为对象） ●半编译半解释（java文件---class文件----虚拟机） ●分布式（多个客户端访问、通过服务器的配置分发到 不同的服务器） ●健壮（异常的处理） ●安全（任何语言都具备、虚拟机沙箱原理） ●多线程、高性能、动态 四、java语言与C、C++语言的不同与区别 ●自动内存管理：Java对于内存的分配是动态的，并具 有垃圾回收机制。 ●不在类外定义全局变量。 ●Java中将不再使用goto语句。
●Java中取消了指针。 ●运行时系统对类型转换进行类型相容性检查 ●Java不支持头文件，使用import与其它类通讯。 ●Java中不包含结构和联合；所有的内容都封装在类中。 ●Java中不支持宏，它通过final 关键字来声明一个常 量。 ●Java不支持多重继承，可以通过Java中的接口实现 多重继承的功能。 ●CC++ 一般情况下都是偏硬件的，java一般偏软件（应 用、基于浏览器） ●（补充）.net、php （网页制作比较快捷）、在安全级 别要求高的企业一般使用java（银行、政府系统） 五、环境的搭建 1、默认路径如下 ●C:\Program Files\Java\jdk1.6.0_02：提供编程中需要 的api包 ●C:\Program Files\Java\jre1.6.0_02：虚拟机文件所在的 位置 2.安装后各个文件夹代表的含义
Java基础知识总结 写代码： 1，明确需求。我要做什么？ 2，分析思路。我要怎么做？1,2,3。 3，确定步骤。每一个思路部分用到哪些语句，方法，和对象。4，代码实现。用具体的java语言代码把思路体现出来。 学习新技术的四点： 1，该技术是什么？ 2，该技术有什么特点(使用注意)： 3，该技术怎么使用。demo 4，该技术什么时候用？test。 ----------------------------------------------------------------------------------------------- 一：java概述： 1991 年Sun公司的James Gosling等人开始开发名称为 Oak 的语言，希望用于控制嵌入在有线电视交换盒、PDA等的微处理器； 1994年将Oak语言更名为Java； Java的三种技术架构: JAVAEE：Java Platform Enterprise Edition，开发企业环境下的应用程序，主要针对web程序开发； JAVASE：Java Platform Standard Edition，完成桌面应用程序的开发，是其它两者的基础；
JAVAME：Java Platform Micro Edition，开发电子消费产品和嵌入式设备，如手机中的程序； 1，JDK：Java Development Kit，java的开发和运行环境，java 的开发工具和jre。 2，JRE：Java Runtime Environment，java程序的运行环境，java 运行的所需的类库+JVM(java虚拟机)。 3，配置环境变量：让java jdk\bin目录下的工具，可以在任意目录下运行，原因是，将该工具所在目录告诉了系统，当使用该工具时，由系统帮我们去找指定的目录。 环境变量的配置： 1）：永久配置方式：JAVA_HOME=%安装路径%\Java\jdk path=%JAVA_HOME%\bin 2）：临时配置方式：set path=%path%;C:\Program Files\Java\jdk\bin 特点：系统默认先去当前路径下找要执行的程序，如果没有，再去path中设置的路径下找。 classpath的配置: 1）：永久配置方式：classpath=.;c:\;e:\ 2）：临时配置方式：set classpath=.;c:\;e:\ 注意：在定义classpath环境变量时，需要注意的情况如果没有定义环境变量classpath，java启动jvm后，会在当前目录下查找要运行的类文件；
1.本讲内容：集合collection （数组和集合90%功能相似，但是最大的区别是，数组在初始化的时候必须确定大小，而集合不用，而且集合是一堆的类，使用起来非常方便。） 讲集合collection之前，我们先分清三个概念： 1colection 集合，可用来存储任何对象的一种数据结构（容器）。 2Collection 集合接口，指的是，是Set、List 和Queue 接口的超类接口 3Collections 集合工具类，指的是类。 SCJP考试要求了解的接口有：Collection , Set , SortedSet , List , Map , SortedMap , Queue , NavigableSet , NavigableMap, 还有一个Iterator 接口也是必须了解的。 SCJP考试要求了解的类有：HashMap , Hashtable ,TreeMap , LinkedHashMap , HashSet , LinkedHashSet ,TreeSet , ArrayList , Vector , LinkedList , PriorityQueuee , Collections , Arrays 下面给出一个集合之间的关系图： 上图中加粗线的ArrayList 和HashMap 是我们重点讲解的对象。下面这张图看起来层级结构更清晰些。 我们这里说的集合指的是小写的collection，集合有4种基本形式，其中前三种的父接口是Collection。 4List 关注事物的索引列表 5Set 关注事物的唯一性 6Queue 关注事物被处理时的顺序 7Map 关注事物的映射和键值的唯一性 一、Collection 接口 Collection接口是Set 、List 和Queue 接口的父接口，提供了多数集合常用的方法声明，包括add()、remove()、contains() 、size() 、iterator() 等。 add(E e) 将指定对象添加到集合中 remove(Object o) 将指定的对象从集合中移除，移除成功返回true,不成功返回false contains(Object o) 查看该集合中是否包含指定的对象，包含返回true,不包含返回flase size() 返回集合中存放的对象的个数。返回值为int clear() 移除该集合中的所有对象，清空该集合。 iterator() 返回一个包含所有对象的iterator对象，用来循环遍历 toArray() 返回一个包含所有对象的数组,类型是Object toArray(T[] t) 返回一个包含所有对象的指定类型的数组 我们在这里只举一个把集合转成数组的例子，因为Collection本身是个接口所以，我们用它的实现类ArrayList做这个例子：例子1： package edu.xjfu;
java知识点总结 应同学要求，特意写了一个知识点总结，因比较匆忙，可能归纳不是很准确，重点是面向对象的部分。 java有三个版本：JAVA SE 标准版\JAVA ME移动版\JAVA EE企业版 java常用命令：java, javac, appletview java程序文件名：.java, .class java的两类程序：applet, application; 特点，区别，这两类程序如何运行 java的主方法，主类，共有类；其特征 java的数据类型，注意与C++的不同，如字符型，引用型，初值 java与C++的不同之处，期中已总结 java标记符的命名规则 1）标识符有大小写字母、下划线、数字和$符号组成。 2）开头可以是大小写字母，下划线，和$符号（不能用数字开头） 3）标识符长度没有限制 4）标识符不能使关键字和保留字 面向对象的四大特征 抽象、封装、继承、多态 封装，类、对象，类与对象的关系，创建对象，对象实例变量 构造函数，默认构造函数，派生类的构造函数，构造函数的作用，初始化的顺序，构造方法的重载 构造函数：创建对象的同时将调用这个对象的构造函数完成对象的初始化工作。把若干个赋初值语句组合成一个方法在创建对象时一次性同时执行，这个方法就是构造函数。是与类同名的方法，创建对象的语句用new算符开辟了新建对象的内存空间之后，将调用构造函数初始化这个新建对象。 构造函数是类的特殊方法： 构造函数的方法名与类名相同。 构造函数没有返回类型。 构造函数的主要作用是完成对类对象的初始化工作。 构造函数一般不能由编程人员显式地直接调用。 在创建一个类的新对象的同时，系统会自动调用该类的构造函数为新对象初始化。 类的修饰符：public类VS 默认; abstract类; final类; 1）类的访问控制符只有一个：public，即公共的。公共类表明它可以被所有其他类访问和引用。 若一个类没有访问控制符，说明它有默认访问控制特性，规定该类智能被同一个包中的类访问引用（包访问控制）。 2）abstract类：用abstract修饰符修饰的类被称为抽象类，抽象类是没有具体对象的概念类，抽象类是它所有子类的公共属性集合，用抽象类可以充分利用这些公共属性来提高开发和维护效率。 3）final类：被final修饰符修饰限定的，说明这个类不能再有子类。所以abstract与final 不能同时修饰一个类。 域和方法的定义 1)域：定义一个类时，需要定义一组称之为“域”或“属性”的变量，保存类或对象的数据。
帮助 | 留言交? | 登录 首页我的图书馆主题阅读精彩目录精品文苑Tags 会员浏览好书推荐 以文找文 如何对文章标记，添加批注？ Java 中集合?用法总结（转载） wade0564 收录于2010-07-08 阅读数：查看 收藏数：7 公众公开 原文来源 tags ： java 集合类 欢迎浏览 wade0564 个人图书馆中收藏的文章，想收藏这篇好文章吗，赶快 吧，1分钟拥有自己的个人图书馆！ 我也要收藏 举报 Java 中集合?用法总结 收藏 Collection ├List │├LinkedList │├ArrayList （异步，线程不安全，空间用完时自动增长原容量一半）│└Vector （同 步，线程安全，空间用完时自动增长原容量一倍）│ └Stack └Set ├HashSet └TreeSet Map ├Hashtable ├HashMap ├WeakHashMap └TreeMap Map 接口： | + -- WeakHashMap: 以弱键 实现的基于哈希表的 Map 。在 WeakHashMap 中，当某个键不再正常使用时，将自动移除其条 | 目。更精确地说，对于一个给定的键，其映射的存在并不阻止垃圾回收器对该键的丢弃，这就使该键成为 可终止的，被终 | 止，然后被回收。丢弃某个键时， 其条目从映射中有效地移除，因此，该类的行为与其他的 Map 实现有所不同。此实现 | 不是同步的。 | + -- TreeMap:该映射根据其键的自然顺序进行 排序，或?根据创建映射时提供的 Comparator 进行 排序，具体取决于使用的 | 构造方法。此实现不是同步的。 | + -- HashMap:基于哈希表的 Map 接?的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了 | 非同步和允许 使用 null 之外，HashMap 类与 Hashtable ?致相同。）此类不保证映射的顺序，特别是它不保证该顺 | 序恒久不变。此实现不是同步的。 | +-- SortedMap: 进一步提供关于键的总体排序 的 Map 。该映射是根据其键的自然顺序进 行排序的，或?根据通常在创建有 序映射时提供的 Comparator 进行排序。对有序映射的 collection 视图（由 entrySet 、keySet 和 values 方法返回 ）进行迭代时，此顺序就会反映 出来。要采用此排序方式，还需要提供一些其他操作（此接?是 SortedSet 的对应映 射）。 Collection 接口： | 热点推荐 中国经典汤品——广东汤常用多音字汇总 如果你失恋。。。这些话...影响世界的100个管理定律汽车发动机?作过程和原理分析温家宝总理答中外记?问女人味，有多少男人可以读懂？珍稀的白头叶猴（组图）三鹿门事件之——中国，...国家公务员职务与级别当代古筝四美 付娜《渔...生活?秘方 真的很实用...哲理?品：守护梦想聚会时可以玩的?游戏依赖型人格障碍的表现和治疗经典妙语，十分精彩江边施救[贴图]李一男2003年在港湾...电脑速度慢的解决方法 ...重装系统后必须做的10件?事
复习题2 如有雷同，纯属巧合！ 1.下列哪一种叙述是正确的() A. abstract修饰符可修饰字段、方法和类 B.抽象方法的body部分必须用一对大括号{ }包住 C.声明抽象方法，大括号可有可无 D.声明抽象方法不可写出大括号 2.下列说法正确的有() A. class中的constructor不可省略 B. constructor必须与class同名，但方法不能与class同名 C. constructor在一个对象被new时执行 D.一个class只能定义一个constructor 3.以下哪个表达式是不合法的（） A、String x=”Hello”; int y=9; x+=y; B、String x=”Hello”; int y=9; if(x= =y) { } C、String x=”Hello”; int y=9; x=x+y; D、String x=null; int y=(x!=null)&&(x.length()>0) ? x.length() : 0 4.下列关于修饰符混用的说法，错误的是（） A．abstract不能与final并列修饰同一个类 B．abstract类中不可以有private的成员 C．abstract方法必须在abstract类中 D．static方法中能处理非static的属性 5.（）修饰符允许对类成员的访问不依赖于该类的任何对象 A、abstract B、static C、return D、public 6.关于被私有访问控制符private修饰的成员变量，以下说法正确的是（） A．可以被三种类所引用：该类自身、与它在同一个包中的其他类、在其他包中的该类的子类 B．可以被两种类访问和引用：该类本身、该类的所有子类 C．只能被该类自身所访问和修改 D．只能被同一个包中的类访问
1、Collection： 集合框架的由来：因为每个容器对象的自身的数据结构不同，所以对它们进行单独的描述和对象封装，并不断的向上抽取共性内容，这样变形成了集合框架。 定义：集合就是一个容器、用来存储对象、长度可变。 理解：其实班级就是一个容器，班上的每一个学生都是单独封装了功能的对象，因为班级中的人数由于有人请假每天都再变化，所以长度是可变的， 常见方法： 1、增加： add();增加一个元素 addAll();增加一部分元素。 2、删除： Remove();删除一个元素，会返回boolean类型，其实用到是equals方法，所以判断是否有符合要求的元素。如果删除成功会改变集合的长度。下面同理。 removeAll();删除全部 Clrea();清空容器 总结：在这里要尤其注意，面试题中经常考到。 3、判断： Contains();是否包含，也就说要所有的都包含在其中才算包含，否则不算包含。 isEmpty();集合是否为空 Size();集合长度。 4、取： retainAll();取交集。 理解总结： 班级就是一个容器，班级中进来一位新生就是Add()添加一个元素，来了一堆同学就是
addAll，班上出去一个学生就是remove删除一个，出去一部分就是removeAll删除一部分，班级是不是有人，isEmpty,班上是否包含张三contains，班上有多少人size。班上是否包含隔壁班的同学retainAll.去交集。 集合使用细节： 1、直接存储基本数据类型值也是可以的，因为JDK1.5后有自动装箱，会将基本 数据类型转成对象，JDK1.4绝对不行。Eg:coll.add(3) 2、集合对象中存储的其实是对象的元素的引用。 3、Add的参数是Object类型，可以接收所有的类型的对象，会出现向上转型， 取出元素时类型还是Object不能使用具体对象的特有内容，想要使用特有内容向下转型。Eg:Object obj="obj";想要取出访问子类的特有方法，向下转型，String s=(String)it.next();sop(s.length()); |--List：有序列表(存取顺序是一致的)因为该子体系元素中有索引或角标，可以 存储重复的元素。 常用方法： //添加： List.add(1,"abc7");//[abc1,abc7,abc2,abc3]在角标1位置往后顺延。 //删除 Object obj=list.remove(2);//删除指定索引上的元素，根据角标删除会返回来被删对象 Sop(obj);//obj：abc2 [abc1,abc7,abc3] //获取:获取指定角标上的元素并返回，这也是和remove的区别。 Object obj=list.get(1); Sop(obj);//obj:abc1 [abc1,abc7,abc3] //获取元素的索引，如果元素存在返回索引，不存在返回-1，依次还可以判断元素是否存在。 Int index=list.indexOf("abc1"); Sop(index);//index=1 //获取指定的子列表sublist(fromIndex,toindex)包含头不包含尾 List=list.sublist(1,2);//[abc1] //修改： Object obj=list.set(1,"haha"); Sop(obj);//[abc1,haha,abc3] 记住：只有list集合支持增删改查。 |--ArrayList：低层是数组数据结构，不同步，查询快，增删慢， |--LinkedList：低层是链表数据结构，不同步，查询慢，增删较快。 |--Vector：低层是数组数据结构，同步，安全效率低，还有其特有方法枚 举。由于名称过长被iterator取代。 总结：掌握这些集合的方法，它们的方法和list集合的方法很相似，重点掌握
基础 1.object类的方法有哪些 clone() protect 创建并返回一个对象的副本 equals()用来比较某个对象是否与调用此方法的对象相等 finalize() protect getClass() 返回一个对象的运行时类 hashCode()返回一个对象的hash值 notify()唤醒在此对象监听器上等待的单个线程。如果有多个，则随机唤醒一个 notifyAll()唤醒在此对象监听器上等待的所有线程 registerNatives() 本地私有方法，在类初始化是会调用此方法 toString() 返回当前对象的字符串表示 wait()使当前线程处于等待直到其他线程调用这个对象的notify或notifyAll方法或者超过指定的时间量 2.接口和抽象类的区别 1.首先描述接口和抽象类的特性 抽象类：是子类通用特性的集合 接口:是抽象方法的集合l 从某种意义上说抽象类包含了接口的所有功能。但是通过实现接口可以实现多继承
什么时候用抽象类和接口 1.如果一些方法必须提供默认的实现，就必须用抽象类，比如在dao层，每个类都有增删查改这几个操作，我们可以把这些操作写在抽象类里，并让抽象类提供默认的实现。 否则的话用接口 2.假如要实现多继承，则必须要用接口,java不支持多继承但是可以通过实现多个接口来解决 3.如果基本功能在不断改变，那么就用抽象类。如果不断改变基本功能并且使用接口，子类就必须不停的更改 03.抽象类是否有构造方法 抽象类有构造方法只是抽象类不能够实例化 4.Final finally finalize()方法的区别 5.Sleep()和wait()的区别 ①这两个方法来自不同的类分别是，sleep来自Thread类，和wait来自Object类。sleep是Thread的静态类方法，谁调用的谁去睡觉，即使在a线程里调用b的sleep方法，实际上还是a去睡觉，要让b线程睡觉要在b的代码中调用sleep。 ②锁: 最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。 sleep不出让系统资源；wait是进入线程等待池等待，出让系统资源，其他线程可以占用CPU。一般wait不会加时间限制，因为如果wait线程的运行资源不够，再出来也没用，要等待其他线程调用notify/notifyAll唤醒等待池中的所有线程，才会进入就绪队列等待OS 分配系统资源。sleep(milliseconds)可以用时间指定使它自动唤醒过来，如果时间不到只能调用interrupt()强行打断。 Thread.sleep(0)的作用是“触发操作系统立刻重新进行一次CPU竞争”。 ③使用范围：wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，配合synchronized实现等待通信机制，而sleep可以在任何地方使用。 synchronized(x){ x.notify() //或者wait() }
javaweb知识点总结 篇一：javaweb期末复习知识点整理 1、 Web应用概述 1. URL与URI URL: 统一资源定位器 URI：统一资源定位符 2. 常见HTML标签 3. 表单的处理 4. 静态文档与动态文档的概念：静态文档是一种以文件的形式存放在服务器端的文档，客户发出对该文档的请求，服务器返回这个文档。动态文档是指文档的内容可根据需要动态生成，又可分为服务器端动态文档和客户端动态文档技术。 5. Servlet概念：服务器端小程序，是使用ServletAPI 以及相关类编写的java程序，主要用来扩展web服务器的功能。 6. 处理404错误：查看给定的路径名是否正确，查看Servlet类文件是否在classes目录下，查看文件内容是否正确，查看tomcat是否启动 2、 Servlet技术模型 1. Servlet的API：包，包 Servlet接口及方法 :
1） public void init(ServletConfig config)：完成Servlet初始化并准备提供服务。容器传给该方法一个ServletConfig类型的参数。 2）public void service(ServletRequest req,ServletResponse res)throw ServletException,IOException：对每个客户请求容器调用一次该方法，它允许Servlet为请求提供响应。 3） public void destroy()该方法由容器调用，指示Servlet清除本身，释放请求的资源并准备结束服务。 4） public ServletConfig getServletConfig()返回关于Servlet的配置信息，如传递给init()方法的参数。 5） public String getServletInfo()返回关于Servlet 的信息，如作者，版本及版权信息。 ServleConfig接口作用及方法 HttpServlet类 :新的service方法，doGet，doPost HttpServletRequest接口及常用方法 HttpServletResponse接口及常用方法 2. Servlet的开发步骤 编写一个Servlet类 编译 部署 (1)在tomcat的虚拟目录下，创建Web目录
Java集合框架之List详解 ArrayList 首先我们熟悉下ArrayList类中常用方法的使用。 1）添加：public boolean add（Object e)：将指定的元素（对象）添加到此列表的尾部 2）获取：public Object get(int index)：返回此列表中指定位置（索引）上的元素。 3）元素的个数：public int size()：返回此列表中的元素数。 4）清空：public void clear()：移除此列表中的所有元素。此调用返回后，列表将为空。 5）是否为空：public boolean isEmpty()：如果此列表中没有元素，则返回 true 6）移除（删除）：public E remove(int index)：移除此列表中指定位置上的元素。向左移动所有后续元素（将其索引减 1）。 7）移除（重载）：public boolean remove(Object o)：移除此列表中首次出现的指定元素（如果存在）。如果列表不包含此元素，则列表不做改动。更确切地讲，移除满足 (o==null ? get(i)==null : o.equals(get(i))) 的最低索引的元素（如果存在此类元素）。如果列表中包含指定的元素，则返回 true （或者等同于这种情况：如果列表由于调用而发生更改，则返回 true）。8）获得索引：public int indexOf(Object o): 返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。更确切地讲，返回满足(o==null ? get(i)==null : o.equals(get(i))) 的最低索引 i ，如果不存在此类索引，则返回 -1。 如何使用这些方法，代码如下： import java.util.ArrayList; public class ArrayListTest { public static void main(String[] args) { ArrayList list=new ArrayList(); /* * 添加 */ list.add("hello"); list.add(" world"); list. add(" welcome"); /* * 获得 */ String s1=(String)list.get(0);