java中重载 java中，&&和&以及|和||的区别？

java中，&&和&以及|和||的区别？  

java中，&&和&以及|和||的区别？

&&
逻辑与,如果第一个条件满足就不会继续向下做判断了
比如if(1>5 && 1>6)
这里 1是肯定小于5的也就是说1>5肯定是"假" 那么按照"与"计算的原则
有一个为假则结果肯定为假 那么程式将不会再去判断1是否大于6
&
位与，它刚好与上面的相反,也就是说不管第一项结果怎样,都要接下来
去判断后一项的结果
就像上面的例子即使明知整个结果为假,也要去对1>6做一个判断。就好想
不亲眼看到结果就不信一样
| 和 ||的区别与上面的相似,就不在说了
就提的使用，要看你程式的具体目的了,如果你只是想求的最后的结果，不需要
让所有项走一遍那么用&&和||来做判断就好了，如果不是这样那么就用&和|

Java中Runnable和Thread以及Callable的区别

区别：Thread是类，而Runnable是介面。
抽象类和介面的区别如下：
① 在类来继承抽象类时，只需实现部分具体方法和全部抽象方法，而实现介面则要实现里面的全部方法。
②在介面中无成员变数，而抽象类中可有成员变数。
在Java中引进介面主要是为了解决多继承的问题。
实现多执行绪主要继承Thread 类和实现Runnable介面。

在java中，其实java中实现 多执行绪有三种方法，一种是继承Thread类；第二种是实现Runnable介面；第三种是实现Callable介面。
1，继承Thread
Thread类是在java.lang包中定义的。一个类只要继承了Thread类同时覆写了本类中的run()方法就可以实现多执行绪操作了，但是一个类只能继承一个父类，这是此方法的侷限。
下面看例子：
package .thread.demo;
class MyThread extends Thread{
private String name;
public MyThread(String name) {
super();
this.name = name;
}
public void run(){
for(int i=0;i<10;i++){
System.out.println("执行绪开始："+this.name+",i="+i);
}
}
}
package .thread.demo;
public class ThreadDemo01 {
public static void main(String[] args) {
MyThread mt1=new MyThread("执行绪a");
MyThread mt2=new MyThread("执行绪b");
mt1.run();
mt2.run();
}
}
但是，此时结果很有规律，先第一个物件执行，然后第二个物件执行，并没有相互执行。在JDK的文件中可以发现，一旦呼叫start()方法，则会通过JVM找到run()方法。下面启动start()方法启动执行绪：
package .thread.demo;
public class ThreadDemo01 {
public static void main(String[] args) {
MyThread mt1=new MyThread("执行绪a");
MyThread mt2=new MyThread("执行绪b");
mt1.start();
mt2.start();
}
};
这样程式可以正常完成互动式执行。那么为啥非要使用start();方法启动多执行绪呢？
在JDK的安装路径下，src.zip是全部的java源程式，通过此程式码找到Thread中的start()方法的定义，可以发现此方法中使用了private native void start0();其中native关键字表示可以呼叫作业系统的底层函式，那么这样的技术成为JNI技术（java Native Interface）
2，Runnable介面
在实际开发中一个多执行绪的操作很少使用Thread类，而是通过Runnable介面
public interface Runnable{
public void run();
}
例子：
package .runnable.demo;
class MyThread implements Runnable{
private String name;
public MyThread(String name) {
this.name = name;
}
public void run(){
for(int i=0;i<100;i++){
System.out.println("执行绪开始："+this.name+",i="+i);
}
}
};
使用Runnable定义的子类中没有start()方法，只有Thread类中才有。此时观察Thread类，有一个构造方法：public Thread(Runnable targer)此构造方法接受Runnable的子类例项，也就是说可以通过Thread类来启动Runnable实现的多执行绪。（start()可以协调系统的资源）：
package .runnable.demo;
import .runnable.demo.MyThread;
public class ThreadDemo01 {
public static void main(String[] args) {
MyThread mt1=new MyThread("执行绪a");
MyThread mt2=new MyThread("执行绪b");
new Thread(mt1).start();
new Thread(mt2).start();
}
}
两种实现方式的区别和联络：
在程式开发中只要是多执行绪肯定永远以实现Runnable介面为主，因为实现Runnable介面相比继承Thread类有如下好处：
1,避免点继承的侷限，一个类可以继承多个介面。
2,适合于资源的共享
Runnable介面和Thread之间的联络：
public class Thread extends Object implements Runnable
发现Thread类也是Runnable介面的子类。
3，Callable介面
Callable 和 Runnable 的使用方法大同小异， 区别在于：
1.Callable 使用 call（） 方法， Runnable 使用 run() 方法
2.call() 可以返回值， 而 run()方法不能返回。
3.call() 可以丢掷受检查的异常，比如ClassNotFoundException， 而run()不能丢掷受检查的异常。
Callable示例如下：
Java程式码
class TaskWithResult implements Callable<String> {
private int id;
public TaskWithResult(int id) {
this.id = id;
}
@Override
public String call() throws Exception {
return "result of TaskWithResult " + id;
}
}
public class CallableTest {
public static void main(String[] args) throws InterruptedException,
ExecutionException {
ExecutorService exec = Executors.newCachedThreadPool();
ArrayList<Future<String>> results = new ArrayList<Future<String>>(); Future 相当于是用来存放Executor执行的结果的一种容器
for (int i = 0; i < 10; i++) {
results.add(exec.submit(new TaskWithResult(i)));
}
for (Future<String> fs : results) {
if (fs.isDone()) {
System.out.println(fs.get());
} else {
System.out.println("Future result is not yet plete");
}
}
exec.shutdown();
}
}

Runnable和Callable的区别是，
(1)Callable规定的方法是call(),Runnable规定的方法是run().
(2)Callable的任务执行后可返回值，而Runnable的任务是不能返回值得
(3)call方法可以丢掷异常，run方法不可以
(4)执行Callable任务可以拿到一个Future物件，Future 表示非同步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并获取计算的结果。计算完成后只能使用 get 方法来获取结果，如果执行绪没有执行完，Future.get()方法可能会阻塞当前执行绪的执行；如果执行绪出现异常，Future.get()会throws InterruptedException或者ExecutionException；如果执行绪已经取消，会跑出CancellationException。取消由cancel 方法来执行。isDone确定任务是正常完成还是被取消了。一旦计算完成，就不能再取消计算。如果为了可取消性而使用 Future 但又不提供可用的结果，则可以宣告Future<?> 形式型别、并返回 null 作为底层任务的结果。Future介面的定义如下：
Future模式
Future模式在请求发生时，会先产生一个Future凭证给发出请求的客户，它的作用就像是Proxy物件，同时，由一个新的执行执行绪持续进行目标物件的生成（Thread-Per-Message），真正的目标物件生成之后，将之设定至Future之中，而当客户端真正需要目标物件时，目标物件也已经准备好，可以让客户提取使用。
结合JDK的Future来看，就是你run执行绪后，你可以把执行绪的返回值赋给Future并返回一个Future物件。这时你可以立即拿到这个物件，然后进行下面的逻辑。但是如果你要get这个Future中的执行绪结果，就会被阻塞直到执行绪结束。
就相当于现在的期房，你把手续和钱都交上去了，就可以马上拿到合同，但只有合同没有房子。这个时候你已经是有房一族了，你可以先去买家电买装修（走下面的其他逻辑）。但是你要把家电和装修放进去，就必须等到房子完工（阻塞）。

java中arraylist和linkedlist以及vector的区别

ArrayList ;LinkedList;Vector 三个都一个爹:List介面麾下
ArrayList;Vector 底层是一样,都是阵列资料结构
LinkedList:底层是连结串列资料结构!
早期没有这么多集合,就一个Vector,后来他被ArrayList取缔了:
因为Vector增删与查询都很慢,但是他安全,逐渐退出舞台,另外(列举中还是能看到它)!
后来ArrayList出现了,增删不是很快,查询非常快!它可以安全也可以不安全,因为Collections工具
可以对Arraylist进行打包,这是针对多执行绪情况下的打包加锁的安全操作!
所以开发中,ArrayList用的是最多的了!
Arraylist查询快,LinkedList增删快,为了结合这两个集合的优点:HashMap降生了!
其实说精确一点:是为了结合阵列查询的优点和连结串列的增删优点...

java和 javaw 以及 javaws的区别

两个应用程式都能执行你的程式，并非常相似，但是有一个重要的区别，java通过控制台执行，javaw则不是。
控制台几乎是为纯文字编成的，例如如果你用javaw执行所有你列印的状态不会被打印出来。你列印在程式中的有用资讯，错误资讯也是一样。
所以，如果你在选择用哪个：
如果是基于纯文字的编成用java。
如果是图形化但随时列印成纯文字用java。
如果你在检查错误，用java。
如果程式是纯粹的图形化的，而且你需要提升速度，用javaw。

java arraylist和linkedlist以及vector的区别

同步性
Vector是同步的。这个类中的一些方法保证了Vector中的物件是执行绪安全的。而ArrayList则是非同步的，因此ArrayList中的物件并不是执行绪安全的。因为同步的要求会影响执行的效率，所以如果你不需要执行绪安全的集合那么使用ArrayList是一个很好的选择，这样可以避免由于同步带来的不必要的效能开销。
资料增长
从内部实现机制来讲ArrayList和Vector都是使用阵列(Array)来控制集合中的物件。当你向这两种型别中增加元素的时候，如果元素的数目超出了内部阵列目前的长度它们都需要扩充套件内部阵列的长度，Vector预设情况下自动增长原来一倍的阵列长度，ArrayList是原来的50%,所以最后你获得的这个集合所占的空间总是比你实际需要的要大。所以如果你要在集合中储存大量的资料那么使用Vector有一些优势，因为你可以通过设定集合的初始化大小来避免不必要的资源开销。
使用模式
在ArrayList和Vector中，从一个指定的位置（通过索引）查询资料或是在集合的末尾增加、移除一个元素所花费的时间是一样的，这个时间我们用O(1)表示。但是，如果在集合的其他位置增加或移除元素那么花费的时间会呈线形增长：O(n-i)，其中n代表集合中元素的个数，i代表元素增加或移除元素的索引位置。为什么会这样呢？以为在进行上述操作的时候集合中第i和第i个元素之后的所有元素都要执行位移的操作。这一切意味着什么呢？
这意味着，你只是查询特定位置的元素或只在集合的末端增加、移除元素，那么使用Vector或ArrayList都可以。如果是其他操作，你最好选择其他的集合操作类。比如，LinkList集合类在增加或移除集合中任何位置的元素所花费的时间都是一样的?O(1)，但它在索引一个元素的使用缺比较慢－O(i),其中i是索引的位置.使用ArrayList也很容易，因为你可以简单的使用索引来代替建立iterator物件的操作。LinkList也会为每个插入的元素建立物件，所有你要明白它也会带来额外的开销。
最后，在《Practical Java》一书中Peter Haggar建议使用一个简单的阵列（Array）来代替Vector或ArrayList。尤其是对于执行效率要求高的程式更应如此。因为使用阵列(Array)避免了同步、额外的方法呼叫和不必要的重新分配空间的操作。

java基础之 “==”和“ equals”以及instanceof的区别

"==" 是判断物件的地址是否相同；
“equals”是判断两个物件的值是否相同；
instanceof：如果 object 是 class 的一个例项，则 instanceof 运算子返回 true。如果 object 不是指定类的一个例项，或者 object 是 null，则返回 false。

有关java上传和File以及FileInputStream的区别

File是档案类，而FileInputStream是档案流，你可以用FileInputStream得到File的输入流，例：

File file1=new File("D:a.xls");FileInputStream fis=new FileInputStream(file1);File file2=new File("D:b.xls");FileOutputStream fos=new FileOutputStream(file2);byte[] b=new byte[1024];int a=0;while((a=fis.read(b))>0){ fos.write(b);}fis.close();fos.close();上述程式码可以将a.xls档案读入b.xls档案中

File是档案
File f=new File(档案路径);""要用"\"表示
FileInputStream是档案输入流，就是用来读资料的
相应有个FileOutputStream输出流，是写档案的
具体怎么用可以网上找例项