黑马程序员技术交流社区

标题: 学习总结(做为个人准备面试复习所用)分享. [打印本页]

作者: 郑飞 时间: 2014-10-21 02:24
标题: 学习总结(做为个人准备面试复习所用)分享.
本帖最后由郑飞于 2014-10-24 06:56 编辑

这两天会陆续发一些比较重要的章节总结笔记,为面试做准备;(多线程,集合,集合工具;;;(3楼泛型,线程池(高新2))
因为主要是为自己准备的,所以有些烂透的东西,不做记录,语言尽量简洁;
很多地方都是个人的理解,不是视频中或别人笔记中copy,包括用词习惯等等;
总之个性的东西,只能说仅供参考,欢迎意见和纠错,照顾不到所有人胃口难免的;
---------------------------------------------------->
多线程总结
      进程:应用程序线程:控制单元例子:多线程(服务器300K,A单线程,B双线程,300/(1+2)=100,A100K,B200K);
      存在理由:切换(软件),快速执行(硬件),实现同时运行的效果;
      区别:其实就是应用程序和控制单元的区别,进程独立空间,线程栈独立,堆共享;
      创建:1.继承Thread重写run 2:传入Runnable子类重写run 区别:Runnable操作的数据是传入子类中的 Thread子类操作数据是本身,前者更适用于共享数据的操作;
      状态:
            1.创建new
            2:运行start()
            3:冻结wait()sleep();
            4:消亡 run运行结束当处于冻结无法控制停止时使用Interrupt清除冻结恢复到阻塞然后控制停止
            5:阻塞被切换清醒瞬间创建瞬间
      控制:
            1:上面的第3,4点,常规;
            2:join 在A线程中使用B的join 效果是:A立马冻结把本属于A的执行权给B 等B结束才恢复A的运行注:其他线程该怎么运行还是造就;
            3:守护线程 setDaemon(true) 在start之前; 效果:当非守护都消亡后,守护自动消亡(后台线程)
            4:yield 让当前线程等待注:不是进入阻塞,所以有可能刚等待的线程,有抢到资源继续执行;
      安全:当数据共享操作时,要加锁,否则可能操作到其他线程操作一半的数据,出现重大问题;
      解决:
            1.synchronize代码块
            2.synchronized方法
            3.ReentrantLock类对象的显式锁,可配多个Condition对象,对锁实现选择性控制;
      代码:共享数据间隔操作
<-------------------------------------------------------
类似以上这种,相当精简了,基本需要每个词自己去扩展内容,相信对某些人有用处;
--------------------------------------------------------->
集合1
      *Collection:

      存在理由:对象用来封装数据,集合用来存对象;同时弥补数组的不足之处;
      区别:可变长度,同一容器对于不同类对象的存放,操作性强(API);
      多分支:存储方式(数据结构)的不同(为了实现各分支个性存储和操作);
      API:
            增:add(),addAll(Collection);
            删:clear();remove();removeAll(Collection);
            改:retainAll(Collection)取交集;toArray();
            查:iterator();contains()containsAll(Collection);isEmpty();size();

      *Collection-List:(后面分支都这样表示,不做缩进,上级共性不再提了)

      特点:有序(存取顺序相同),可以重复.(索引)
      增:add(index);add(index,Colletion);
      删:remove(index);
      改:set(index,Object);subList(fromIndex,toIndex);
      查:get(index);indexOf(Object);lastIndextOf();firstIndextOf();
      listIterator();除Iterator中有的remove()外,增加了add(),set();和倒序迭代hasPrevious(),previous();previousIndex();

      *ArrayList:数组,不同步,改查快增删慢;长度默认10,50%增长;
      *LinkedList:链表,不同步,增删快,改查慢;
            特点:添addFirst();取getFirst();取删removeFirst()可控存取顺序
                     先进后出:(像日常生活中的瓶子);
                     后进先出:(像日常生活中的管子);
                     模拟堆栈或队列数据结构:新建类,构造对象时new个LinkedList,用其LinkedList的存取方法重新写自己的存入取出方法
            get和remove会抛出NoSuchElementException;
            1.6后pullFirst替removeFirst,peekFirst替getFirst;offerFirst替addFirst(不抛异常,返回布尔值)
      *Vector:数组结构,同步,增删改查都很慢;长度默认10,100%增长;
            特点:1.0的时候枚举迭代方式(其他方式一样可以用)
                     for(Enumeration e = v.elements();e.hasMoreElements();)
                                 System.out.println(e.nextElement());
            这种方法现在只用在properties中
      Vector1.0出现的,集合框架1.2出现的
      Collections有方法可以得到线程安全的ArrayList对象;所以即使Vector同步,由于效率低照样被取代了;
            static List synchronizedList(List list) 返回同步list。

      *Collection-Set:
      特点:无序(存入取出顺序不同),不可重复.(无索引),功能和Collection是一致的;
      Set判断相等用equals,而不是==。返回true,Set集合是不会接受第二个对象。

      *HashSet:HashTable数据结构; 不同步;允许null;
      特点:判断相等先hashCode,再equals(hashCode可以做到完全不一样,为什么还重写equals,感兴趣的可以关注下)
      注:hash算法的功能:主要提高检索速度(大概意思张老师提过);
      应该尽量保证两个对象通过equals比较返回true时,他们的hashCode返回也相等。

      *TreeSet有序存放:二叉树;对存入元素排序;(所以存入之前必须可以比较)
            1.实现Comparable接口重写compareTo方法;
            2.构造TreeSet的时候传入一个比较器自定义比较器(实现Comparator接口);
            3.两种都存在的时候,以比较器为主;
      注:也可以实现堆栈和队列效果,控制compareTo的结果;
      Comparator comparator():返回当前Set使用的Comparator,若返回null,表示以自然顺序排序。
      first() 返回第一个元素。 last() 返回最后一个元素。
      有部分API相关到其父接口 SortedSet,可以看看;
<---------------------------------------------------------------
---------------------------------------------------------------->

集合2
      *Map
      特点:
            键值对,key不重复,对应唯一的value(注:value能重复,但1key只对1value)
            Map里的key集存储方式和对应的Set集合中的元素存储方式一致
            Map.Entry内部接口，保存key-value;
      共性方法:(基本字面就能理解,记不住就是用少了.)
            clear();containsKey(Object key);containsValue(Object  value);isEmpty();entrySet();keySet();
            put();返回被覆盖的value;putAll(Map m);remove(Object key);size();Collection values():
      *Map.Entry

      Entry是Map接口里面的一个内部接口.
            该接口用于封装key- value,有3个方法:getKey();getValue();setValue(Object value)返回旧value;

      迭代:(注:嵌套泛型归到泛型)
            1.entrySet(),取出entry集,然后遍历,同时取出key和value;
            2.keySet(),取出key集,遍历,同时取出value
      *HashTable:哈希表,键值对非空,同步;
      *HashMap:哈希表,与HashTable的区别:允许空键值对,非同步;
      *TreeMap:二叉树,非同步,可对键排序;
<----------------------------------------------------------
---------------------------------------------------------->
集合3
      *工具类
      *Collections
      reverse(List list):反转顺序;shuffle(List list):随机排序;sort(List list):自然升序排序;swap(List list,int i, int j):元素交换；
      rotate(List list, int distance):[a, b, c, d, e]执行Collections.rotate(l.subList(1, 4), -1);后结果:[a, c, d, b, e](建议查API)
      binarySearch(List list, Object key) 二分搜索获得指定对象,必须先调用 Collections.sort(List list)(完成自然排序);
      max(Collection coll) 根据自然顺序，返回最大元素。min(Collection coll)返回最小元素。fill(List list, Object obj)用obj完全填充所有位置。
      frequency(Collection c, Object o)  返回等于指定对象的元素个数。
      indexOfSubList(List source, List target) 返回第一次出现的起始位置,如果没有则返回 -1。对应的last方法:lastIndexOfSubList(List source, List target)
      replaceAll(List list, Object oldVal, Object newVal)  使用另一个值替换所有某一指定值。
      *Arrays

      List asList(Object... a)返回的是不可变的List(长度固定)。注:不能增删;这个方法和Collection.toArray()方法充当了数组与collection之间的桥梁。
      例子:List<String> list= Arrays.asList("A", "B", "C");可变参数"A", "B", "C",同数组,此数组被转成固定长度的list;
      其他方法都是对基本类型数组转成list后的常规操作方法,看API;
<----------------------------------------------------------

作者: 戏言丶 时间: 2014-10-21 03:14
先来占个楼。。。飞哥依然那么晚睡

作者: 郑飞 时间: 2014-10-21 03:26
本帖最后由郑飞于 2014-10-24 08:57 编辑

戏言丶发表于 2014-10-21 03:14
先来占个楼。。。飞哥依然那么晚睡

.......还有活人:o
1楼放不下了这里接着
----------------------------------------------------------->
泛型
      存在理由:解决类型安全,免去强制转换;
      格式:<类型>
      注:重写equals不能用,=左右泛型必须一样
      使用:
            泛型类(要操作引用类型不确定又想要扩展,早期用Object,现在用泛型),
            泛型类结合泛型方法使用:类上定义一个,部分方法上再定义另一个;
      例子:
            泛型类和泛型方法综合使用,就这个例子够了;接口上使用泛型,没什么特殊的不写了;
      class Test<T> //类泛型定义在类名后
      {
            //方法泛型定义在返回值前
            public <I>void method(T t,I i)//类泛型和方法自定义泛型在同一个方法中
            {
                     System.out.println(t);
                     System.out.println(i);
                     //System.out.println(t+i);//不能这么用泛型局限性
            }
            public static void main(String[] args)
            {
                     new Test().method("abc",100);
                     new Test().method(120,"bc");
            }
      }
      限定:
            <?>和<T>的区别,方法体中可以存在T t =....;而 ? 没这个用法;
            ? super E; ? extends E; 多看视频,类似这种东西掌握后就不会再变,越早掌握越好.别人提过的就不写了,除此之外真不知道该怎么总结;
      嵌套:
            Map迭代<Entry<Integer, String>>
<-------------------------------------------------------
线程并发库(其实是高新部分,不含空中网):
      存在理由:
            Tcp服务端例子,大量用户不断的访问和消亡,致使普通多线程必须不断新建和销毁线程,极其影响服务器性能.所以引入线程池原理;
            把任务交给线程池处理,池中的线程运行完手上的任务后不销毁,处于空闲等待任务状态.提高了服务器性能.
      种类:
            固定线程池 ExecutorService threadPool=Executors.newFixedThreadPool(5) 固定为5个线程;
            缓存线程池 newCachedThreadPool();有多少任务就有多少线程当任务减少超时一定时间后线程也会减少;
            单一线程池 newSingleThreadExecutor();不同于单线程,它有固定线程池的特性,保持线程数量(该线程死亡后重新恢复一个线程);

      关闭线程池:
            pool.shutdown()(池中无任务就关闭池)和shutdownNow()(调用该方法后,当前任务结束后关闭线程池)
      线程池定时器:
            new RunnableSchedulePool(int i).schedule(runnable,多久后运行,时间单位)
            new RunnableSchedulePool(int i).scheduleAtFixedRate()(runnable,多久后运行,间隔时间,时间单位)
      读写锁妙用:嵌套读写锁,实现对象缓存系统高效访问;
      Semaphere同步工具:
            规定N个线程同时访问,多了就进不去;实际上就是一个升级的锁;
            原来的锁一般控制单线程在操作资源,而Semaphere锁,能判断当前进持有该锁的线程数量,控制固定数量线程的访问;
      CyclicBarrier同步工具:
            规定N个线程,都执行到cb.await()的时候,才全体运
            运用环境:多线程起点终点一样,运行速度不一样;(日常集体出游例子);
      CountDownLatch同步工具:
            在逻辑线程外多起一个线程用于控制该同步工具的计数器;
            当计数器数值为0的时候,使用了该工具的多个线程,同时继续运行;(计数器1倒计时起跑,计数器2等待结果,最后公布成绩)
            计数器1,1个人通知多个人,计数器2,多个人通知1个人;
      Exchange同步工具:
            两个线程执行完成事务后,早完成的人等待第二个人完成后,二着交易数据;
      阻塞队列:
            就是了解添加和移除的3套API
            运用:用两个长度为1的队列实现互相通知间隔运行这样的同步效果;
      同步集合类:
            HashMap死循环原理,循环的时候,集合remove()了一次,使得hasNext()无限为真(courosr超过了集合长度后无限++,判断都为真);
            CopyOnWriteArrayList():迭代过程中删除元素出现coursr长度出现问题造成错误,可以同个这个类屏蔽这个问题;
            实际上,remove()后使用previous(),也一样可以解除这个问题;(http://bbs.itheima.com/thread-149741-1-1.html)
----------------------------------------------------->
反射(高新1)
HelloWorld:
java中的类是用来描述普通事物的(内部有什么特征,什么功能等等),而反射中很重要的类Class,是用来描述<java中的类>这类事物的;
Class描述了某个java类内部有什么属性什么方法,各种参数,等等;反射就是基于Class这个类展开的;也就是反射的源;
获取字节码:
1.类名.class;2.对象.getClass();3.Class.forname(记住加包名String classname);
字节码类型:
基本数据类型对象:
8个基本类型和void类型:int.class,long.class,void.class等等;判断(isPrimitive();)
封装类中的属性:Integer.TYPE == int.class;
数组类型:
int[].class;判断isArray();
注意点:
不写权限修饰,其实是protected,也是要使用暴力反射的;
反射数组为参数的方法时(比如某个类的main函数),invoke(这里数组要转成Object,否则会被1.5的可变参数原理拆开)
权限: clazz.newInstance()只要能访问就能反射而普通getXxx()反射只能反射public修饰的内容
数组:
类型判断,数组之间,只要元素类型一样,维度一样,就表示两个类型一样;(编译都不通过)
Array.get(arr, index)(这里没用到它的字节码,判断是否是数组的时候可以用字节码)

API: 不记录了,就那几个;暴力反射记住getDeclared和setAccessible这两个单词;
补充: 泛型在编译成.class文件后就消失了,现在需求需要获取泛型的参数列表;
通过反射该泛型的方法,然后反射方法中的参数类型;getGenericParameterTypes();参数类ParameteriezdType,用其中方法获取参数类型;
<---------------------------------------

作者: 戏言丶 时间: 2014-10-21 03:28

郑飞发表于 2014-10-21 03:26
.......还有活人

不要奇怪，我也是奋战在第一线的:lol。。。飞哥不是面试了47期的吗？

作者: 郑飞 时间: 2014-10-21 03:29
本帖最后由郑飞于 2014-10-26 07:58 编辑

戏言丶发表于 2014-10-21 03:28
不要奇怪，我也是奋战在第一线的。。。飞哥不是面试了47期的吗？

没啊有事时间紧而且不自信就没参加反正啥时候整明白了再面试可能快了
------------------------------------------->
IO流
      实际上就是通过java语言调用系统资源(各种平台的本地方法)从各种数据处理设备中获取和写入数据的工具;
      最常用的就是缓冲流,在流内部定义缓冲数组,实现数据批量读取和写入,从而提高数据转移的效率;
      缓冲流就是利用java语言调用本地方法将数据读取到流内部的数组中当数组装满后自动存入目的地
      至此,字节缓冲流已经可以应付基本的数据处理;但是java为了提高开发的效率,就提供了各种高级的有针对性的功能流;
      以下就各种高级流做阐述:
      1.BufferedReader,BufferedWriter/字符缓冲流
            最显著的功能提升就是,行读取:readLine();这个流的write()方法可以自动判断缓冲流中数据是否装满,装满了会自动刷新到目的地,所以不用每次都刷新;
      2.LineNumberReader,基于BufferedReader增加了行符这个属性,可以获取,自定义,修改行符;
      学到这里,插入File概念:这是一个文件系统的封装类,将文件,文件夹封装成一个对象,扩展了流的操作范围(流只能操作数据,File的引入,使流可以间接的操作文件系统);
      File类中有各种功能API对File对象进行各种操作,常用的有,新建,删除,获取文件名,获取上级File,获取子级File列表,判断是文件还是文件夹;(复制多级文件夹中用到这些)
      合并流只有读取流,其功能是将多个读取流拼成一个读取流:也就是将多个地方的数据(每个数据都关联一个普通读取流),统一输出到一个目的地(合并目的地);
      反过来切割就简单了,把源输入到一个输入流,这个输入流对应多个输出流,输出到不同的目的地;(用最基本的流就能实现,没新知识);

      以上就是IO流中最常用,最基本的东西;下面列举一些有针对性的流:
      1.ObjectInputStream:操作对象的流;将对象数据化,存入到硬盘上;要点:使用前要将对象序列化,即对象所在类实现Serializable接口;
      补充:
            为了方便序列化,自定义常量public static final long serialVersionUID = 35l;效果:当类改变后,一样可以识别该类,使得原有的对象可以使用在改变后的类中;
            静态成员不能序列化;transient修饰成员,可以强行不对该成员序列化;
      2.PipedInputStream(PipedInputStream pis)管道流:普通流输入--数组--输出,而管道流:输入--输出;(必须使用多线程,处理同步问题)
            管道流需要使用多线程的原因:于其他流比较,管道流从代码变现形式上少了中间中转(其实内部还是有中转的),那我们就无法使用循环控制到二者的运行顺序,造成了同步安全问题;
            由于结构上和以往流的区别,所以要结合视频中的例子,看API此2个类的类说明,记住数据流向;Input读取(),Output写入;
      RandomAccessFile:
                     随机访问文件;直接继承Object;内部封装了字节输入输出流;
                     使用的时候可以指定读取模式r只读和rw读取,r的时候,如果文件不存在怎报错,rw的时候如果文件不存在,怎创建;
                     内部相当于数组,没write()一次,相当于存入一个数组元素,所以该读取的时候通过变动指针实现针对性读取(随机读取,想读哪就读哪);所以存的时候数据长度最好

要有规律,这样才好控制指针;
                     读:seek(8)直接定位(象棋车)从第9个位置开始取;skipBytes(),只能往下跳不能往回走(象棋卒);
                     写:指针控制和读一样,写入动作其实是修改功能,直接覆盖当前位置数据;
                     由于write()只读8位造成数据丢失的特点,该类提供了对基本数据类型的写入和读取,writeInt(),readInt();
            用处:对数据的分段写入和读取;例子存取个人信息(姓名按16字节8个字长度存,名字4个字节32位(int)长度存),长度统一后,进行遍历或者单取,都很方便;
      DataInputStream:                操作基本数据类型就用这个流;
      ByteArrayInputStream:
            用流的存取思想来操作数组元素;
            接收一个byte数组为数据源;ByteArrayOutputStream数据目的地为其内部封装的缓冲数组,会自动增长长度;(可以理解为其对象就是一个数组,可使用数组方法),还有个特殊方法writerTo()把数据放到另外一个流中,例如FileInputStream();
            同类流:CharArrayReader,CharArrayWriter;StringReader,StringWriter;
      编码问题:
            能指定编码的流InputStreamReader,OutputStreamWriter;PrintStream,PrintWriter(只能打印)
            编码 String--byte[] :str.getBytes(charsetName);解码: byte[]--String:new String(byte[],charsetName);
            解决乱码:编一次解一次;
<--------------------------------------------------

作者: 戏言丶 时间: 2014-10-21 03:42

郑飞发表于 2014-10-21 03:29
没啊有事时间紧而且不自信就没参加反正啥时候整明白了再面试可能快了 ...

没事，这种事急不来，我也准备了蛮长时间的。飞哥可要注意身体，都这么晚，虽然我也挺晚的

作者: 郑飞 时间: 2014-10-21 03:50

戏言丶发表于 2014-10-21 03:42
没事，这种事急不来，我也准备了蛮长时间的。飞哥可要注意身体，都这么晚，虽然我也挺晚的 ...

嗯我是老毛病了你们还没成习惯的千万别太晚很难改的差不多了就睡了

作者: 戏言丶 时间: 2014-10-21 04:06

郑飞发表于 2014-10-21 03:50
嗯我是老毛病了你们还没成习惯的千万别太晚很难改的差不多了就睡了

我也有一段时间了。。。这个点差不多了，睡了

作者: HM2014nuli 时间: 2014-10-21 08:30
感谢分享

作者: 我为你着迷 时间: 2014-10-21 08:33
表示你写的这些术语感觉好深奥啊有木有

作者: 郑飞 时间: 2014-10-21 08:47

我为你着迷发表于 2014-10-21 08:33
表示你写的这些术语感觉好深奥啊有木有

有些和视频里差不多只是用了自己的语言总结的这样我个人容易记还有些觉得看了视频还不理解平时有百度看过还有的就是有意简化成简练的语言所以有些部分比如多线程会多一点自己的词语集合的感觉API多一点应该还好供大家参考结合你们自己的总结就好了

作者: 黄小橙 时间: 2014-10-21 08:59
谢谢分享~

作者: 张周飞 时间: 2014-10-21 09:12
睡的比...晚起的比鸡晚........ 好奋斗的骚年

作者: 菜鸟一号 时间: 2014-10-21 09:13
楼主晚睡且早起？

作者: 郑飞 时间: 2014-10-21 09:28
前些天有事拉下不少，这两天恶补下，不过休息了几天回过头来能真正知道自己到底掌握多少还缺那里，发扬下阿Q精神。

作者: 千里马 时间: 2014-10-21 10:08
飞哥精神值得我们学习，总结的内容很好！

作者: 十万一千 时间: 2014-10-21 13:12
总结很不错。。。:handshake

作者: T-l-H、小生 时间: 2014-10-21 13:45
嗯，好东西。。。

作者: 贾浩田 时间: 2014-10-22 00:25
楼主是流弊达人，鉴定完毕，向你学习

作者: 郑飞 时间: 2014-10-22 01:13

贾浩田发表于 2014-10-22 00:25
楼主是流弊达人，鉴定完毕，向你学习

不是的因为面试要求知识系统性比较强而自己动脑做总结能深刻的系统的复习所有知识我觉这是个"捷径"

作者: 静水流华 时间: 2014-10-22 14:33
你已经是高级黑马了，哈哈

作者: suoxidong 时间: 2014-10-22 21:19
谢谢楼主

作者: Eric1225 时间: 2014-10-22 22:25
收藏了，楼主给力啊

作者: 郑飞 时间: 2014-10-22 22:58

Eric1225 发表于 2014-10-22 22:25
收藏了，楼主给力啊

没什么主要章节还差线程池反射IO总结下就差不多了应该不到一半了明天就差不多了

作者: Jason森 时间: 2014-10-22 23:36
谢谢啊啊

作者: treanow 时间: 2014-10-23 01:31
大神已收藏谢啦！！如果我有问题会跟你交流的~~

作者: winkyqin 时间: 2014-10-23 14:08
学习学习！

作者: 林兴才 时间: 2014-10-24 10:35
感谢分享

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2