代码混装

一个很平常的路线，mvc-servcie-dao-hibernate的结构
----------------------------------------------------------------------------------------
int n=Integer.parseInt("123");
String s=String.valueOf(int a);
泛型 的作用：可以提取事物的共性操作，然后具体的实现通过具体的类实现，可以理解为多态的扩充
计算机里面的数都是补码形势的。


被标记为transient的属性在对象被序列化的时候不会被保存
int[] arr1 = {1, 2, 3, 4, 5}; 
int[] arr2 = Arrays.copyOf(arr1, new_length);//Arrays是数组的工具类
//ArrayList的转化为静态数组的toArray方法就是这个原理
//ArrayList的扩容原理也是Arrays.copyOf()方法
//新建了一个数组


定义一个数组int[] a={3,1,4,2,5}; int[] b=a; 数组b只是对数组a的又一个引用，即浅拷贝。
如果改变数组b中元素的值，其实是改变了数组a的元素的值
要实现深度复制，可以用clone或者System.arrayCopy
如下面的代码
1 int[] a={3,1,4,2,5};
2 int[] b=a.clone();
3 b[0]=10;
4 System.out.println(b[0]+" "+a[0]);
输出为10 3
可见改变了b的值，但是没有改变a的元素的值
------------------------------------------------------------------------------------------------基于比较的排序算法是不能突破O(NlogN)的


1、假设淘宝一天有5亿条成交数据，求出销量最高的100个商品并给出算法的时间复杂度。


2、给一列无序数组，求出中位数并给出算法的时间复杂度。


3、输入一个整型数组，求出子数组和的最大值，并给出算法的时间复杂度。


4、给出10W条人和人之间的朋友关系，求出这些朋友关系中有多少个朋友圈（如A-B、B-C、D-E、E-F，这4对关系中存在两个朋友圈），并给出算法的时间复杂度。


5、如图所示的数字三角形，从顶部出发，在每一结点可以选择向左走或得向右走，一直走到底层，要求找出一条路径，使路径上的值的和最大。给出算法的时间复杂度。


6、有一个很长二进制串，求出除以3的余数是多少，给出算法的时间复杂度。
------------------------------------------------------------------------------------------------
所谓的OR映射就是通过java的对象，使用反射得到对象的信息，然后产生SQL语句，再使用JDBC对数据库进行操作。


当一个同步方法已经执行，线程能够调用对象上的非同步实例方法吗？ 
可以，一个非同步方法总是可以被调用而不会有任何问题。在一个对象上两个线程可以调用两个不同的同步实例方法吗？ 
不能，因为一个对象已经同步了实例方法，线程获取了对象的对象锁。所以只有执行完该方法释放对象锁后才能 执行其它同步方法。
同步方法的锁，是类本身：XXX.class 
根据反射机制，这个类是Class类的子类，所以class是唯一的，只有释放后才能被其他的同步方法继续获得。你的问题有个前提：当一个同步方法已经执行，所以不可以调用两个不同的同步实例方法

对象序列化就是把对象存放到字节流，可以写到文件中保存，之后还可以从文件中读取。


队列是一种复杂的数据结构，其底层的实现不一定要用数组实现，根据特殊需求，可以用最大堆实现，
每次出队的都是最大的那个，入队和出队的复杂度均为O(logN)


对于程序员来说，分配对象使用new关键字；释放对象时，只要将对象所有引用赋值为null，让程序不能够再访问到这个对象，我们称该对象为"不可达的".GC将负责回收所有"不可达"对象的内存空间。
对于GC来说，当程序员创建对象时，GC就开始监控这个对象的地址、大小以及使用情况。通常，GC采用有向图的方式记录和管理堆（heap）中的所有对象。通过这种方式确定哪些对象是"可达的"，哪些对象是"不可达的".当GC确定一些对象为"不可达"时，GC就有责任回收这些内存空间。


MyObject对象在finalize中变成可达对象，但是下次回收时候，finalize却不再被调用，因为finalizec函数最多只调用一次
根据GC的工作原理，我们可以通过一些技巧和方式，让GC运行更加有效率，更加符合应用程序的要求。一些关于程序设计的几点建议：
1）最基本的建议就是尽早释放无用对象的引用。
2）尽量少用finalize函数。
程序员可以手动执行System.gc()，通知GC运行，但是Java语言规范并不保证GC一定会执行

Servlet是运行在Web服务器端的Java程序，用java语言编写，具有java语言的优点。与一般java程序的区别是Servlet对象封装了对HTTP请求的处理，并且它t的运行需要Servlet容器的支持。Servlet需要在Java编译器编译后才能运行，如果Servlet在编写完成或修改后没有被重新编译，就不能运行在Web容器中.而JSP页面中的内容没有变化时，JSP的编译完成之后，JSP Container不会对JSP再次编译。JSP的产生：把Servlet中的HTML，CSS，JS等相关代码写到JSP页面中，简化程序员对Web程序的开发。


 GET提交的数据会放在URL之后，以?分割URL和传输数据，参数之间以&相连，如EditPosts.aspx?name=test1&id=123456.  POST方法是把提交的数据放在HTTP包的Body中.
. GET提交的数据大小有限制（因为浏览器对URL的长度有限制），而POST方法提交的数据没有限制.
 GET方式提交数据，会带来安全问题，

 （servlet接口中使用了servletRequest,servletResponse.
也是是说，如果不存在servletRequest,servletResponse那么servlet接口衍生出来的类就不能正常工作，这就是依赖）

任何一个Servlet对象都要直接或者间接实现javax.servlet.Servlet接口，Servlet中，主要方法是service()，当客户请求到来时，Servlet容器将调用Servlet实例的service()方法对请求进行处理。ServletConfig接口位于javax.servlet包中，它封装了Servlet的配置信息，在Servlet初始化期间被传递。公共接口类HttpServletRequest继承自javax.servlet.ServletRequest接口.客户端浏览器发出的请求被封装成为一个HttpServletRequest对象。所有的信息包括请求的地址，请求的参数，提交的数据，上传的文件客户端的ip甚至客户端操作系统都包含在其内。HttpServletResponse继承了ServletResponse接口，并提供了与Http协议有关的方法，这些方法的主要功能是设置HTTP状态码和管理Cookie。HttpServletResponse的setRedirect（url）方法将客户端的浏览器重定向到一个新的Internet地址。


继承httpservlet类来开发servlet  ：1.通过重写doget ,dopost方法来实现 ；  get的安全性小于post会在浏览器上显示 get信息 ,get提交的数据部能大于2K post提交的数据不受限制 ，介意少于64K     2.响应速度get>post

我们创建了一个Servlet对象就要实现Servlet接口中的5个方法，这样操作不方便，所以产生了GenericServlet类，它是抽象类，它实现了上述3个接口，但没有对Http请求处理进行实现，这一操作由HttpServlet实现，我们所编写的Servlet类都继承于HttpServlet，HttpServle类是Servlet的实现类，并提供了Http请求的处理方法。


（Servlet对象 在Servlet容器启动时被初始化，当第一次被请求时，Servlet容器将其实例化，此时它贮存于内存中。如果存在多个请求，Servlet不会再被实例化，仍然由此Servlet将其进行处理，每一个请求都是一个线程，而不是进程，因此，Servlet对  请求的处理的性能非常高。）

无后效性就是“未来与过去无关”，当前的状态是此前历史的一个完整总结，此前的历史只能通过当前的状态去影响过程未来的演变。具体地说，如果一个问题被划分各个阶段之后，阶段I中的状态只能由阶段I-1中的状态通过状态转移方程得来，与其它状态没有关系，特别是与未发生的状态没有关系。


索引是对记录按照多个字段进行排序的一种方式,对表中的某个字段建立索引会创建另一种数据结构，其中保存着字段的值，每个值又指向与它相关的记录.唯一性索引和主键索引的区别：前者可以为空，唯一索引是不允许其中任何两行具有相同索引值的索引。  B+树非叶节点中存放的关键码并不指示数据对象的地址指针，非也节点只是索引部分。所有的叶节点在同一层上，包含了全部关键码和相应数据对象的存放地址指针，且叶节点按关键码从小到大顺序链接。


怎样在大文件中寻找关键词，字典树


递归 和 递推（斐波那契数列，相当于双指针）0 1 2 3 5 8 13 21 


单链表的逆置 头插法（用到双指针？）


空指针异常，内存溢出，内存泄露，buffer溢出，数组。。。


字节流在操作时本身不会用到缓冲区（一段内存区），是文件本身直接操作的，而字符流在操作时使用了缓冲区，通过缓冲区再操作文件。
（流是个抽象的概念，是对输入输出设备的抽象，Java程序中，对于数据的输入/输出操作都是以“流”的方式进行。设备可以是文件，网络，内存等。）
Java所有的流类位于java.io包中，都分别继承字以下四种抽象流类型。
  字节流        字符流
输入流 InputStream Reader
输出流 OutputStream Writer
字节流转化为字符流，实际上就是byte[]转化为String


jsp的getParameter（）和getAttribute（）区别
getParameter() 返回的是String，用于读取表单中的值
getAttribute()返回的是Object对象，需进行转换 获取的是session的值


线程池就像数据库连接池一样，是一个对象池。所有的对象池都有一个共同的目的，那就是为了提高对象的使用率，从而达到提高程序效率 的目的。


所谓的依赖注入，就是依赖关系的控制权转移到外部容器，即组件之间的依赖关系由容器在运行期决定，
形象地来说，就是容器动态地将某种依赖关系注入到组件中。依赖关系放在配置文件里。
（spring会在系统运行到适当的时候，把你要的东西主动给你）
AOP代理类：AOP代理方法=增强处理+目标对象方法

（IdentityHashMap与常用的HashMap的区别是：前者比较key时是“引用相等”而后者是“对象相等”）
（HashMap是非线程安全的，只是用于单线程环境下，多线程环境下可以采用concurrent并发包下的concurrentHashMap。）


一些技巧可以让我们对共享资源的同步访问更加安全：
1． 定义private 的instance变量+它的 get方法，而不要定义public/protected的instance变量。如果将变量定义为public，对象在外界可以
绕过同步方法的控制而直接取得它，并改动它。这也是JavaBean的标准实现方式之一。
对象/变量前加上 volatile 。 Volatile修饰的 成员变量 在每次被 线程 访问时，都强迫从 共享内存 中重读该成员变量的值。而且，当 成员变量 发生变化时，强迫线程将变化值回写到 共享内存 。
当要访问的 变量 已在synchronized代码块中，或者为 常量 时，不必使用


当一个同步方法已经执行，线程能够调用对象上的非同步实例方法吗？ 


可以，一个非同步方法总是可以被调用而不会有任何问题。
在一个对象上两个线程可以调用两个不同的同步实例方法吗？ 
不能，因为一个对象已经同步了实例方法，线程获取了对象的对象锁。所以只有执行完该方法释放对象锁后才能执行其它同步方法。

接口回调是指：可以把使用某一接口的类创建的对象的引用赋给该接口声明的接口变量，那么该接口变量就可以调用被类实现的接口的方法。实际上，当接口变量调用被类实现的接口中的方法时，就是通知相应的对象调用接口的方法，这一过程称为对象功能的接口回调。

synchronized 关键字，它包括两种用法：synchronized 方法和 synchronized 块。

sleep()和wait（）的区别
最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法
要等待其他线程调用notify/notifyAll唤醒等待池中的所有线程
如果需要在线程间相互唤醒的话就需要借助Object.wait(), Object.nofity()
从语法角度来说就是Obj.wait(),Obj.notify必须在synchronized(Obj){...}语句块内。从功能上来说wait就是说线程在获取对象锁后，主动释放对象锁，同时本线程休眠。直到有其它线程调用对象的notify()唤醒该线程，才能继续获取对象锁，并继续执行。相应的notify()就是对对象锁的唤醒操作。但有一点需要注意的是notify()调用后，并不是马上就释放对象锁的，而是在相应的synchronized(){}语句块执行结束，自动释放锁后，JVM会在wait()对象锁的线程中随机选取一线程，赋予其对象锁，唤醒线程，继续执行。这样就提供了在线程间同步、唤醒的操作。Thread.sleep()与Object.wait()二者都可以暂停当前线程，释放CPU控制权，主要的区别在于Object.wait()在释放CPU同时，释放了对象锁的控制。

典型的垃圾收集算法（内存分为：可回收，存活，未使用）
1.Mark-Sweep（标记-清除）算法　最基础的垃圾回收算法，之所以说它是最基础的是因为它最容易实现，思想也是最简单的标记-清除算法分为两个阶段：标记阶段和清除阶段。
标记阶段的任务是标记出所有需要被回收的对象，清除阶段就是回收被标记的对象所占用的空间。
2.Copying（复制）算法:为了解决Mark-Sweep算法的缺陷，Copying算法就被提了出来。它将可用内存按容量划分为大小相等的两块，每次只使用其中的一块。当这一块的内存用完了，就将还存活着的对象复制到另外一块上面，然后再把已使用的内存空间一次清理掉，这样一来就不容易出现内存碎片的问题。
3.Mark-Compact（标记-整理）算法 为了解决Copying算法的缺陷，充分利用内存空间，提出了Mark-Compact算法。该算法标记阶段和Mark-Sweep一样，但是在完成标记之后，它不是直接清理可回收对象，而是将存活对象都向一端移动，然后清理掉端边界以外的内存
------------------------------------------------------------------------------------------------
强引用  new 出来的引用
软引用（SoftReference）软引用通过SoftReference类来实现，软引用的对象当系统内存充足时和强引用没有太多区别，但内存不足时会回收软引用的对象。
------------------------------------------------------------------------------------------------
辗转相除法while(b!=0){ c=a%b; a=b;  b=c;} a,b是输入，a就是最大公约数 最小公倍数=原a*b/最大公约数
------------------------------------------------------------------------------------------------
动态INCLUDE与静态INCLUDE
<%@include file="path"%>指令是把被包含的文件汇到一起编译，
<jsp:include>动作是单独编译，可以允许有相同的变量。。。（copyright.jsp..嵌入）
<jsp:forward page="login.jsp">是把请求重定向longin.jsp页面
------------------------------------------------------------------------------------------------
每个对象添加一个引用计数器，每被引用一次，计数器加1，失去引用，计数器减1，当计数器在一段时间内保持为0时，该对象就认为是可以被回收得了。但是，这个算法有明显的缺陷：当两个对象相互引用，但是二者已经没有作用时，按照常规，应该对其进行垃圾回收，但是其相互引用，又不符合垃圾回收的条件，因此无法完美处理这块内存清理，因此Sun的JVM并没有采用引用计数算法来进行垃圾回收。而是采用一个叫：根搜索算法，
------------------------------------------------------------------------------------------------
Struts2提供一个ActionContext类，Struts2的Action通过该类访问Servlet API
HttpServlet  HttpSession ServletContext
对应jsp中的request session application


Struts2框架提供了非常强大的输入校验体系，通过内建输入校验器，Struts2应用无须输入代码即可完成大部分校验，并且可以同时完成客户端校验和服务端校验。
Struts2也提供用户自定义校验器。
web接受到的所有数据都是字符串类型的，表现层数据处理包括2个方面：数据类型转换和输入校验


cracker可以轻松绕过客户端校验（防止大部分正常顾客的错误输入，降低服务器的负载），所以服务端校验是必需的，


struts.xml支持多配置文件->团队开发方便


公共接口类HttpServletRequest继承自ServletRequest.
客户端浏览器发出的请求被封装成为一个HttpServletRequest对象。所有的信息包括请求的地址，请求的参数，提交的数据，上传的文件客户端的ip甚至客户端操作系统都包含在其内。HttpServletResponse继承了ServletResponse接口，并提供了与Http协议有关的方法，这些方法的主要功能是设置HTTP状态码和管理Cookie。


public interface HttpServletRequest extends ServletRequest;


public HttpSession getSession();
public HttpSession getSession(boolean create);


返回与这个请求关联的当前的有效的session。如果调用这个方法时没带参数，那么在没有session与这个请求关联的情况下，
将会新建一个session。如果调用这个方法时带入了一个布尔型的参数，只有当这个参数为真时，session才会被建立。


类型转换  文件的上传和下载  拦截器

public class Singleton {  
    private static Singleton instance; 
//堵死外界利用构造方法创建叫该类实例的可能 
    private Singleton (){}  
  //获得本类实例的唯一全局访问点
    public static Singleton getInstance() {  
    if (instance == null) {  
        instance = new Singleton();  
    }  
    return instance;  
    }  
}  
------------------------------------------------------------------------------------------------
java中length,length(),size()区别
1 java中的length属性是针对数组说的,比如说你声明了一个数组,想知道这个数组的长度则用到了length这个属性.
2 java中的length()方法是针对字符串String说的,如果想看这个字符串的长度则用到length()这个方法.
3.java中的size()方法是针对泛型集合说的,如果想看这个泛型有多少个元素,就调用此方法来查看!
------------------------------------------------------------------------------------------------
CPU在一个时刻只能运行一个线程，当在运行一个线程的过程中转去运行另外一个线程，这个叫做线程上下文切换（对于进程也是类似）。在单个程序中同时运行多个线程完成不同的工作，称为多线程.一个应用程序可以有一个或多个进程，一个进程可以有一个或多个线程，其中一个是主线程.
一个进程的所有线程共享它的虚拟地址空间、全局变量和操作系统资源。之所以有线程这个概念，是因为以线程而不是进程为调度对象效率更高：由于创建新进程必须加载代码，而线程要执行的代码已经被映射到进程的地址空间，所以创建、执行线程的速度比进程更快。
一个进程的所有线程共享进程的地址空间和全局变量，所以简化了线程之间的通讯。
Java线程（Thread类创建并控制线程，设置其优先级并获取其状态）
class Demo2 implements Runnable{
    public void run(){
。。。}
 Demo2 d =new Demo2();
        Thread t = new Thread(d);
        t.start();


new Thread(new Runnable(){
            public void run(){
}
}.start();
start()，启动线程。
join()，等待线程运行完毕。
sleep()，让线程休眠一段时间。
setPriority()，设置线程优先级。
　1）start方法


　　start()用来启动一个线程，当调用start方法后，系统才会开启一个新的线程来执行用户定义的子任务，在这个过程中，会为相应的线程分配需要的资源。


　　2）run方法


　　run()方法是不需要用户来调用的，当通过start方法启动一个线程之后，当线程获得了CPU执行时间，便进入run方法体去执行具体的任务。注意，继承Thread类必须重写run方法，在run方法中定义具体要执行的任务。
--------------------- -------------------------------------------------------------------------
StringBuilder：内部也是一个char[]，但是这个数组内容是可变的，并且自动维护扩容算法，因为数据内容可变，所以叫：可变字符串。StringBuilder API方法，是动态维护char[]内容，都可以改变char[]内容。
--------------------- -------------------------------------------------------------------------
如果两个hashCode()返回的结果相等，则两个对象的equals方法不一定相等。
1：Object类的hashCode.返回对象的内存地址经过处理后的结构，由于每个对象的内存地址都不一样，所以哈希码也不一样。
　　2：String类的hashCode.根据String类包含的字符串的内容，根据一种特殊算法返回哈希码，只要字符串内容相同，返回的哈希码也相同。
　　3：Integer类，返回的哈希码就是Integer对象里所包含的那个整数的数值，例如Integer i1=new Integer(100),i1.hashCode的值就是100 。由此可见，2个一样大小的Integer对象，返回的哈希码也一样。


在hashset中又是怎样判定元素是否重复的呢？这就是问题的关键所在,
java的集合中，判断两个对象是否相等的规则是： 
1)判断两个对象的hashCode是否相等 
      如果不相等，认为两个对象也不相等，完毕 
      如果相等，转入2) 
临界区指每个进程中访问 临界资源的那段代码
synchronized的两种使用方法：
 
1）同步对象 synchronized(对象名){临界区}
2）同步方法 public synchronized方法名(参数){临界区}
 
synchronized关键字可以让我们把任何一个Object对象做为同步对象来看待,而Java为每个Object都实现了wait()和notify()方法。它们必须用在被synchronized同步的Object的临界区内。通过的wait()我们可以使得处于临界区内的线程进入阻塞状态，同时释放被同步对象的控制权，而notify操作可以唤醒一个因调用了wait操作而处于阻塞状态中的线程,使其进入就绪状态。被重新换醒的线程会试图重新获得临界区的控制权，并继续执行临界区内wait之后面的代码。如果发出notify操作时没有处于阻塞状态中的线程,那么该信号会被忽略。
--------------------- -------------------------------------------------------------------------
（这一点只是为了提高存储效率而要求的，其实理论上没有也可以，但如果没有，实际使用时效率会大大降低，所以我们这里将其做为必需的。后面会重点讲到这个问题。） 
2)判断两个对象用equals运算是否相等 
      如果不相等，认为两个对象也不相等 
      如果相等，认为两个对象相等（equals()是判断两个对象是否相等的关键） 
为什么是两条准则，难道用第一条不行吗？不行，因为前面已经说了，hashcode()相等时，equals()方法也可能不等，所以必须用第2条准则进行限制，才能保证加入的为非重复元素。 
--------------------- -------------------------------------------------------------------------
给出两个字符串，设计一个算法将两个字符串合并按字母排序。不就是排序后归并嘛，O(nlogn)。然后面试官说有更好的方法吗？又想想，哦，类似荷兰国旗问题，遍历一次统计各字符出现次数，直接按字母顺序输出，O(n)。这下他满意了。所以遇到简单的题目，还是先想清楚再回答。
链表归并排序


设计数据结构可以快速返回0～10亿中哪些数出现了or没出现。这题和一面的一样，而且更简单，125M的bitmap就够了。
--------------------- ------------------------------------------------------------------------
SessionFactory级别的二级缓存是全局性的，所有的Session都共享这个二级缓存。
当Session需要抓取数据时，Session会先查找一级缓存，在查找二级缓存，只有当一级缓存和二级缓存
都没有需要抓取的数据时，才会去查找底层数据库。
缓存都是为了提高数据库访问性能。
--------------------- ---------------------------------------------
java HashMap通过value反查key的代码示例
关键用:  private static ArrayList valueGetKey(Map map,String value) {
    Set set = map.entrySet();
    ArrayList arr = new ArrayList<>();
    Iterator it = set.iterator();
    while(it.hasNext()) {
      Map.Entry entry = (Map.Entry)it.next();
      if(entry.getValue().equals(value)) {
        int s = (int)entry.getKey();
        arr.add(s);
      }
    }
    return arr;
  }
--------------------- ---------------------------------------------
   JDK的版本：  EE(J2EE)，enterprise edition，企业版，使用这种JDK开发J2EE应用程序，从JDK 5.0开始，改名为Java EE。

web服务器只是简单的通过响应(response)html页面来处理http请求(request)。Tomcat
web服务器主要支持的协议就是HTTP，所以通常情况下HTTP服务器和WEB服务器是相等的
WEB服务器与客户端打交道，它要处理的主要信息有：session、request、response、HTML、JS、CS等
WEB服务器一般是通用的，而应用服务器一般是专用的


Web服务器传送(serves)页面使浏览器可以浏览，然而应用程序服务器提供的是客户端应用程序可以调用(call)的方法(methods)。确切一点，你可以说:Web服务器专门处理HTTP请求(request)，但是应用程序服务器是通过很多协议来为应用程序提供(serves)商业逻辑 (business logic)。

HttpServletRequest接口继承于ServletRequest，是ServletRequest对于Http协议的更具体抽象。HttpServletRequest一般是由tomcat，jboss等服务器提供商实现，我们毋须关心其实现逻辑。 所以一般的网站应用开发使用到HttpServletRequest即可。 
ServletRequest是为了多种协议设计的，目前主流还是Http协议。
客户端浏览器发出的请求被封装成为一个HttpServletRequest对象。 
所有的信息包括请求的地址，请求的参数，提交的数据，上传的文件客户端的ip甚至客户端操作系统都包含在其内。HttpServletResponse继承了ServletResponse接口，并提供了与Http协议有关的方法，这些方法的主要功能是设置HTTP状态码和管理Cookie。
--------------------- ---------------------------------------------


for(Integer i : map.keySet())
{
if( map.get(i) ==1)
return i.intValue();
}
//map
--------------------- ---------------------------------------------
，复用的重点其实应该是抽象层的复用，而不是具体某一个代码块的复用


--------------------- ---------------------------------------------
登录按钮 2个线程   返回结果时间不一样导致bug
更新UI只能在单线程，不能使用多线程，所以只能在主线程更新UI
--------------------- ---------------------------------------------
List  Map set等一些基本的用法熟悉  leetcode 


clone


类函数成员的正确行为只是类能够实现要求功能的基础，而类成员
函数之间的交互和类之间的服务调用是单元测试无法确定的。因此
需要进行面向对象的集成测试


Class——类对象（Class 类的实例表示正在运行的 Java 应用程序中的类和接口 ）
Constructor－类的构造器对象，
Field－类的属性对象，
Method－类的方法对象。
//forName("java.lang.String")获取指定的类的对象

Class c = Class.forName("java.lang.String");

IoC 或者 DI 或者 ...一大堆的缩写词不管是面向对象，还是面向过程，都需要分成许多的块，然后由这些部件协同工作完成任务 要协同工作就会产生依赖，一个方法调用另一个方法，一个对象包含另一个对象 如果对象A包含对象B的话，就需要在A里new一个B 依赖注入从具体类B里抽象出接口IB——IB的具体实现可能有很多B,B1,B2...很多种——这样A可以不用再new具体的B了，而是跟IoC容器说：我要一个IB（getBean("IB")）。然后，由容器根据配置文件来做具体的new的工作。具体new的是哪个，由配置文件从代码外部决定，要更换成B,B1,或是B2...修改配置文件就能做到，不用再改代码了


当类的成员变量类型是Java基本类型时（外加String），只要实现简单clone（）就可以，但是如果类的成员变量是数组或者是复杂类型时，就必须实现深度clone（）


简单clone（）A o=(A)super.clone(); return o;
深度clone（）A o=(A)super.clone(); 
o.name=(String[])name.clone();//显示地写出来
return o;
----------------------------------------------------------------------
Bundle类是一个key-value对,
要传输大量数据，用socket
http是轻量级的
----------------------------------------------------------------------
Alt+后退键  代码回退 
--------------------------------------------------------------------


如输出小数点后3位System.out.printlnf("%.f%n",a);


  ‘0’+ 0 =‘0’
           ‘0’+ 1 =‘1’
           ‘0’+ 2 =‘2’
 
---------------------------------------------------------------------


这个学过java的一般都知道怎么用，先以标准输入为参数new 一个Scanner，如果要读入一个int，就用nextInt(),double 就用nextDouble，其他类型依次类推，另外可以用hasNextInt来判断是否还有下一个。至于读入以字符串用next(),读入一行用nextLine();
附上A+B代码
epmzm bpmzm qa eqtt bpmzm qa i eig
[c-sharp] view plaincopy 
import java.io.*;  
import java.util.*;  
public class Main {  
        public static void main(String args[]) {  
                Scanner cin = new Scanner(System.in);  
                int a, b;  
                while (cin.hasNextInt()) {  
                        a = cin.nextInt();  
                        b = cin.nextInt();  
                        System.out.println(a + b);  
                }  
        }  
}  
(System.in是来自控制台的输入Scanner cin = new Scanner(System.in); Scanner可以使用正则表达式来分析基本类型和字符串的简单文本扫描器,构造完毕你就可以从控制台输入一些东西给java了譬如int input = cin.nextInt();)
----------------------------------------------------------------------
PrintStream out = System.out; // 保存原输出流
PrintStream ps=new PrintStream("./log.txt"); // 创建文件输出流
System.setOut(ps); //设置使用新的输出流
----------------------------------------------------------------------
输入输出重定向代码


try {  
BufferedInputStream in = new BufferedInputStream(new FileInputStream("input.txt"));
 System.setIn(in);
 BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

 
PrintStream out = System.out; // 保存原输出流
PrintStream ps=new PrintStream("./output.txt"); // 创建文件输出流
System.setOut(ps); // 设置使用新的输出流

// String s;
//  while((s = br.readLine())!=null)
//  System.out.println(s);
 
 
} catch (FileNotFoundException e) { 
e.printStackTrace(); 
} catch (IOException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
} 
try{PrintStream out =
new PrintStream(
new BufferedOutputStream(
new FileOutputStream("test.out")));}
  catch(IOException e) {
e.printStackTrace();
}
----------------------------------------------------------------------
// 深度优先搜索.cpp : 定义控制台应用程序的入口点。
//


#include "stdafx.h"
#include<String>
#include<iostream>
using namespace std;
const int GNumber=8;
int G[GNumber][GNumber];
int color[GNumber];


void DFS_Visit(int G[][GNumber],int i,int n)
{
int j;
color[i]=1;
for(j=1;j<=n;j++)
{
if(G[i][j]&!color[j])
{
cout<<j<<endl;
DFS_Visit(G,j,n);
}
}
}




int _tmain(int argc, _TCHAR* argv[])
{
memset(color, 0, sizeof(color));
FILE *fr;
int i,j;
fr=fopen("图的遍历测试用例.txt","r");
if(!fr)
{
printf("fopen failed\n");
return -1;
}
while(fscanf(fr,"%d%d",&i,&j)!=EOF)
{
G[i][j]=1;
G[j][i]=1;
}
color[1]=1;
cout<<1<<endl;
DFS_Visit(G,1,GNumber);
getchar();
return 0;

}

----------------------------------------------------------------------

将数据本身与数据存储地址联系起来，这样方便查找其存储地址

开辟大空间需要很大内存，在main函数中难以提供如此大的内存，将出现栈溢出
，导致程序异常终止。开辟大内存必须定义在函数体外，即定义为全局变量
或者在函数中使用malloc等函数申请变量空间。
----------------------------------------------------------------------


                int res=1;//保存最终变量结果
while(B!=0)//对B转换为二进制的过程
{
if(B%2==1)
          res*=A;
B/=2;
A*=A;
}


----------------------------------------------------------------------


struct Edge
{
int Node,nextNode;
int cost;

};
bool cmp(Edge a,Edge b)
{
return a.cost<b.cost;
}






struct Edge
{
int Node,nextNode;
int cost;
bool operator<(const Edge &a)const
{
return cost<a.cost;
}
};
----------------------------------------------------------------------


// 最小生成树_村庄.cpp : 定义控制台应用程序的入口点。
//并查集的应用


#include "stdafx.h"
#include<iostream>
#include<algorithm>
using namespace std;


#define N 5000


struct Edge
{
int Node,nextNode;
int cost;
bool operator<(const Edge &a)const
{
return cost<a.cost;
}
};
/*struct Edge
{
int Node,nextNode;
int cost;

};
bool cmp(Edge a,Edge b)
{
return a.cost<b.cost;
}
*/


int Tree[100];


int findNode(int x)
{
if(Tree[x]==-1)
return x;
else 
return findNode(Tree[x]);
}

int _tmain(int argc, _TCHAR* argv[])
{
Edge edge[N];
int n;
while(cin>>n&&n)
{
for(int i=0;i<100;i++)Tree[i]=-1;
for(int i=0;i<n*(n-1)/2;i++)
{
cin>>edge[i].Node>>edge[i].nextNode>>edge[i].cost;

}
sort(edge,edge+n*(n-1)/2);
for(int i=0;i<n*(n-1)/2;i++)
{
cout<<edge[i].Node<<edge[i].nextNode<<edge[i].cost<<endl;

}
int i=0,sum=0;
   while(n*(n-1)/2-i-1)
{
int a=findNode(edge[i].Node);
int b=findNode(edge[i].nextNode);
if(a!=b)
{
Tree[a]=b;
sum+=edge[i].cost;
}
i++;
}
cout<<sum<<endl;

}

return 0;
}

/****************************************************************/
//数字符串中1的个数

int c1=count(a.begin(),a.end(),'1'); 

sort(v.begin(),v.end(),Comp);
修改排序规则
bool Comp(const string &a,const string &b)
{
int c1=count(a.begin(),a.end(),'1'); 
int c2=count(b.begin(),b.end(),'1'); 
return c1!=c2?c1<c2:c1<c2;
}
//修改排序规则
//如果1的数量相等，则按出现的顺序排序

//否则按ASCII码大小排序

----------------------------------------------------------------------

int i=0;
while(i++<=2);
printf("%d\n",i);//4..........
----------------------------------------------------------------------


//判断是否为素数
bool isPrime(int n)
{
int sqr=sqrt(n*1.0);
for(int i=2;i<=sqr;i++)
{
if(n%i==0)
             return false;
}
return true;
}


----------------------------------------------------------------------
bool isPrime(int n)
{
if(n==1)return false;
if(n!=2&&n%2==0) return false;
for(int i=3;i*i<n;i=i+2)
{
if(n%i==0)return false;
}
return true;
}
----------------------------------------------------------------------


string t;
reverse(t.begin(),t.end());




struct Comp
{
bool operator()(const string &s1,const string &s2)
{
if(s1.length()!=s2.length())return s1.length()<s2.length();


}
}//自定义比较规则

for(multiset<string,Comp>::iterator it=ms.begin();it!=ms.end();it++)
{
   cout<<*it<<endl;
}
----------------------------------------------------------------------
//4位数的对称数不可能是素数
//1000a+100b+10b+a=1001a+110b=11*(91a+10b)
数学！！！！！！！！
----------------------------------------------------------------------


/*欧几里得算法：只要2数不等，就反复用大叔减小数，直到相等为止，
此相等的数就是2数的最大公约数
int gcd(int x,int y)
{
while(x!=y)
{
if(x>y)
x=x-y;
else
y=y-x;
}
return x;
}
int hcf(int a,int b)
{
    int r=0;
    while(b!=0)
        {
        r=a%b;
        a=b;
        b=r;
        }
    return(a);
}//怎么来的？最大公约数

//最大公约数
lcd(int u,int v,int h)
{
    return(v/h*u);
}
----------------------------------------------------------------------
十进制转换为二进制       
while(cin>>n)



if(n==0)
{
cout<<"          0-->0\n"<<endl;
continue;//结束本轮循环，开始下一轮循环
}
s="";
for(int a=n;a;a=a/2)
{
s=s+(a%2?'1':'0');
}
//要求的s应反转
std::reverse(s.begin(),s.end());
const char *sss=s.c_str();
cout.width(11);
cout<<n<<(n<0?"-->-":"-->")<<sss<<endl;
----------------------------------------------------------------------
for(int i=0;i<n;i++)
{
cin>>temp;
v.push_back(temp);
}
----------------------------------------------------------------------
bool cmp (int x,int y)
{
  return x>y;
}
sort(s,s+n,cmp);


----------------------------------------------------------------------
typedef struct st
{
string name;
int age;
unsigned int score;
//利用c++算符重载直接定义小于运算符
//const 干什么的？
bool operator < (const st &b) const {
if(score!=b.score)return score<b.score;  
if(name!=b.name)return name<b.name;
else
return age<b.age;
}
}stu;
java集合2种：
1。Collection 层次结构 中的根接口
子接口set 元素无须  不可重复的集合（类似高中的集合）
   HashSet LinkedHashSet TreeSet
子接口List 元素有序 可重复的集合（动态数组）
    ArrayLit :有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。
Linkedlist
  Vector
2.Map接口 具有映射关系的key-value对的集合 
y=f(x) （x1，y1）
HashMap TreeMap Hashtable


queue tree array string
            HashMap
　　　　　　TreeMap
　　　　　　Hashtable


存储对象：容器 数组
数组弊端：长度不可变
 真实的数组存放对象个数不可知
如果存入集合中的元素是自定义的对象，要求重写equals()方法
iterator()返回一个Iterator接口实现类的对象，进而实现集合的遍历
集合变数组 toArray();
数组变集合 Array.asList(1,2,3);
vector老的实现类 线程安全的 但操作效率不高


红黑树
heap
queue
tree
graph
Integer装箱拆箱什么意思？


泛型：java编程思想   不把程序写死  使程序灵活，易于修改