最近总看到很多讨论Java走下坡路的帖子，新人求澄清！

bigbro001 2012-09-10 01:24:46

虽说发自内心的不怎么喜欢C#，但是C#有很多特性真的比Java好，用起来方便多了，而且近几年来，C#的确是抢占了Java越来越多的市场啊，照这种趋势发展下去，再过5年，Java不会真的被淘汰了吧？

随便举几个例子：
1. C#里DateTime别提多好用了，Java里的Calendar相比起来就垃圾多了，最后还得去用apache的DateUtils来弥补
2. C#的struct简化了很多操作，Java里还要装箱拆箱
3. C#的ADO.NET，Java里有可以类比的好东西么？
4. C#的as关键字，Java里有对应的好东西么？
5. C#的LINQ，lambda expression，Java里有这么好的东西么？

总结起来就是：Java有的好东西C#都有，C#有的很多好东西，Java一个都没有！

新手在此迷茫的请教各位Java前辈，10年内到底Java会不会被C#取代而没落？？

...全文

1431 86 打赏收藏转发到动态举报

写回复

用AI写文章

86 条回复

切换为时间正序

请发表友善的回复…

发表回复

小柚子同学 2012-12-12

打赏
举报

很有道理

引用 10 楼 keithcai 的回复:

引用 8 楼的回复:引用 5 楼的回复: 你喜欢用什么就用什么，不想别人拿大话压你，你就没必要提问了。我相信没人能说那种语言好，java若不好，能生存那么久吗？任何东西都不可能完美。人也一样，哪有十全十美的人，人且如此，编程语言又能怎么样？毕竟还是人开发出来的。你还是老老实实的敲代码去吧。 Java能生存那么久是因为碰到了2次千载难逢的机遇，一次是网……

很有

引用 10 楼 keithcai 的回复:

引用 8 楼的回复:引用 5 楼的回复: 你喜欢用什么就用什么，不想别人拿大话压你，你就没必要提问了。我相信没人能说那种语言好，java若不好，能生存那么久吗？任何东西都不可能完美。人也一样，哪有十全十美的人，人且如此，编程语言又能怎么样？毕竟还是人开发出来的。你还是老老实实的敲代码去吧。 Java能生存那么久是因为碰到了2次千载难逢的机遇，一次是网……

Timesongs 2012-12-12

打赏
举报

不怕不怕，哪个语言好用用哪个~~~

zly361814478 2012-12-12

打赏
举报

不好好学，整天就讨论这些，关于类似的帖子看的都累了。

永恒的罗纳尔多 2012-12-12

打赏
举报

引用楼主 bigbro001 的回复:

虽说发自内心的不怎么喜欢C#，但是C#有很多特性真的比Java好，用起来方便多了，而且近几年来，C#的确是抢占了Java越来越多的市场啊，照这种趋势发展下去，再过5年，Java不会真的被淘汰了吧？随便举几个例子： 1. C#里DateTime别提多好用了，Java里的Calendar相比起来就垃圾多了，最后还得去用apache的DateUtils来弥补 2. ……

如果你只能调调API，那么JAVA的生与死对你而言毫无关系

bigbro001 2012-12-12

打赏
举报

这帖子里言之无物的喷子太多，为什么就不能以平和的心态来探讨探讨未来的趋势呢？严重鄙视那些喷子！

mash5_paul 2012-09-27

打赏
举报

感觉有点像灌水贴

mash5_paul 2012-09-27

打赏
举报

没必要纠结谁会被淘汰，历史的痕迹会证明，学好java、c#都能站住脚

corn8888 2012-09-27

打赏
举报

[Quote=引用 73 楼的回复:]

还有就是java 的枚举。
java enum的好处就是定义枚举单位的属性。比如说一下代码

Java code

public class EnumTest {
public static void main(String[] args) {
for (EnumWithAttribute enumItem :EnumWithAttribute.values())……
[/Quote]

java 枚举一点不好用

mkaser 2012-09-27

打赏
举报

LZ有点二，

云水禅心_ 2012-09-27

打赏
举报

这个话题，完全没有讨论的意义。

伊羽 2012-09-27

打赏
举报

[Quote=引用 41 楼的回复:]

话说明年jdk8就出来了，前瞻一下jdk8的优点吧，不要总是讨论老版本。

List<String>list={"这","写法","如何？"};
还有Java的动态语言等....
[/Quote]
噗~这语法都用了几年了。。。你们还要等啊

xiaofeng1987008 2012-09-27

打赏
举报

[Quote=引用楼主的回复:]
虽说发自内心的不怎么喜欢C#，但是C#有很多特性真的比Java好，用起来方便多了，而且近几年来，C#的确是抢占了Java越来越多的市场啊，照这种趋势发展下去，再过5年，Java不会真的被淘汰了吧？

随便举几个例子：
1. C#里DateTime别提多好用了，Java里的Calendar相比起来就垃圾多了，最后还得去用apache的DateUtils来弥补
2. C#的struct简化了很……
[/Quote]
又是一个变相的java与xxx的灌水帖，从你的言语没看出一点请教的成分，你的目的只是引来人们互喷，说实话你也不用学什么c#，java...还是学好怎样去问问题吧，如果要是想学java的话，你该问问java在什么领域有什么优势，有什么特长，再结合你自身的特点去选择，可你呢，打着菜鸟新手的旗号，说这不好那不好，硬把自己搞的五脊六兽跟个小白似的有意思。人家说java跨平台，你还轻蔑人家小白，你可知道跨平台的意义是什么。
java在服务端，网络，web，搜索等都有很多优秀的框架，技术，近年来吵的很火的hadoop，hbase等都是基于java平台技术的，你还说java会在5年之后淘汰，那人家这些搞开源的“累死累活”的更新版本就是为了淘汰啊，不知道人家是2BT还是你是2BT。
还有些大神，你让我膜拜啊，你搞基java，c#测试啊什么的，你懂测试？你懂jvm？你用的是标准虚拟机吧，你知道jdk跟jrocket是怎么回事？摆脱不要小白好不？大家最好对这样的帖子犹如粪土，视而不见。注册了号这么长时间，就回复了两三次，就看见你们喷了，实在受不鸟了，但也欢迎LZ其他人再来喷我吧。

晓风吹雾 2012-09-24

打赏
举报

还有就是java 的枚举。
java enum的好处就是定义枚举单位的属性。比如说一下代码



public class EnumTest {

    public static void main(String[] args) {

        for (EnumWithAttribute enumItem :EnumWithAttribute.values()) {

            System.out.println(String.format("Enum name:%s, attribute1:%s, attribute2:%s, attribute3:%s   ",

                    enumItem.name(), 

                    enumItem.getAttribute1(), 

                    enumItem.getAttribute2(),

                    enumItem.getAttribute3()  ));

        }

    }



    static enum EnumWithAttribute {

        EnumUnit1("detail1", 1, 1L),

        EnumUnit2("detail2", 2, 2L),

        EnumUnit3("detail3", 3, 3L), 

        EnumUnit4("detail4", 4, 4L), 

        EnumUnit5("detail5", 5, 5L),

        EnumUnit6("detail6", 6, 6L);



        private String attribute1;



        public String getAttribute1() {

            return this.attribute1;

        }



        private int attribute2;



        public int getAttribute2() {

            return this.attribute2;

        }



        private long attribute3;



        public long getAttribute3() {

            return this.attribute3;

        }



        EnumWithAttribute(String attribute1, int attribute2, long attribute3) {

            this.attribute1 = attribute1;

            this.attribute2 = attribute2;

            this.attribute3 = attribute3;

        }

    }

}

.net 可以吗?

有人说可以还给了代码。先看代码。



public enum EnumWithAttribute

    {

        [EnumUnit("detail1", 1, 1L)]

        EnumUnit1,

        [EnumUnit("detail2", 2, 2L)]

        EnumUnit2,

        [EnumUnit("detail3", 3, 3L)]

        EnumUnit3,

        [EnumUnit("detail4", 4, 4L)]

        EnumUnit4,

        [EnumUnit("detail5", 5, 5L)]

        EnumUnit5,

        [EnumUnit("detail6", 6, 6L)]

        EnumUnit6

    }

    [AttributeUsageAttribute(AttributeTargets.Field, Inherited = true, AllowMultiple = false)]

    public class EnumUnitAttribute : Attribute

    {

        public String attribute1;

        public int attribute2;

        public long attribute3;



        public EnumUnitAttribute(String attribute1, int attribute2, long attribute3)

        {

            this.attribute1 = attribute1;

            this.attribute2 = attribute2;

            this.attribute3 = attribute3;

        }

    }

但是如果想得到其中一个EnumUnit4的attribute1的结果【detail4】，该怎么写？
恐怕就没那么方便了吧。

好像还要强制转化吧！！简直太繁琐了。

所有劝楼主还是先精通一门吧，多积累项目经验。如果还是比来比去，最后一事无成！！

老黑NO1 2012-09-24

打赏
举报

java也不行，以后都是苹果机了哈哈。。。。

晓风吹雾 2012-09-24

打赏
举报

说说.net与java的线程池吧
需求都是一样的，都是一系列任务tasks使用固定的线程池去执行。
看看有什么不一样。

说先说说c#下的线程池操作



// 这边要说一下 c# 必须要需要设置 doneEvent，来通知是否完成任务。

// 而且必须在任务执行完毕后finally执行通知

public abstract class AbstractTask

{

        /// <summary>

        /// taskCallBack

        /// </summary>

        /// <param name="parameter"></param>

        public void taskCallBack(Object parameter)

        {

            this.TaskResult = doTask();

        }



        /// <summary>

        /// done Event handler

        /// </summary>

        private ManualResetEvent doneEvent;

        public ManualResetEvent DoneEvent

        {

            get { return doneEvent; }

            set { doneEvent = value; }

        }

}





public class ThreadPoolManager

{

        /// <summary>

        /// 这边设置线程池的大小

        /// </summary>

        private int poolSize;

        private ThreadPoolManager(int poolSize)

        {

            this.poolSize = poolSize;

            System.Threading.ThreadPool.SetMaxThreads(this.poolSize, this.poolSize);

        }



        /// <summary>

        /// 执行 IList<TaskParameter>

        /// </summary>

        /// <param name="taskParameters">task list</param>

        /// <param name="methods">Delegate array</param>

        /// <returns></returns>

        private const int NUM_WAIT_HANDLES = 64; // the number of wait handles

        public List<AbstractTask> startTask(IList<TaskParameter> taskParameters)

        {

            int taskSize = taskParameters.Count;

            List<AbstractTask> tasks = new List<AbstractTask>();

            if (taskSize == 0)

            {

                return tasks;

            }



            Queue<ManualResetEvent> events = new Queue<ManualResetEvent>(taskSize);

            foreach (TaskParameter eachPara in taskParameters)

            {

                AbstractTask task = TaskManger.getTaskInstance(eachPara);

                ManualResetEvent manualResetEvent = new ManualResetEvent(false);

                events.Enqueue(manualResetEvent);

                task.DoneEvent = manualResetEvent;

                tasks.Add(task);

            }



            // task.taskCallBack 执行真正的任务

	    // c# 需要将任务一个一个的加入到tasks池中

            foreach (AbstractTask task in tasks)

            {

                System.Threading.ThreadPool.QueueUserWorkItem(task.taskCallBack, null);

            }



            // 这边还有一个问题就是 等待任务的数量不能超过64，你说郁闷吗？

	    // 那只能批量64个任务 等待了。

            // Wait for completion

            // Due to limitations on WaitAll, must be "chunked" in sets of 64 or fewer wait handles

            List<WaitHandle> handles = new List<WaitHandle>(NUM_WAIT_HANDLES);

            // calculate the number of times that we need to wait

            int loops = ((taskParameters.Count - 1) / NUM_WAIT_HANDLES) + 1;

            //chuncking the waiting

            for (int currentLoop = 0; currentLoop < loops; currentLoop++)

            {

                for (int handleCount = 0; handleCount < NUM_WAIT_HANDLES; handleCount++)

                {

                    if (events.Count == 0)

                    {

                        break;

                    }

                    handles.Add(events.Dequeue());

                }

                WaitAll(handles.ToArray());

                handles.Clear();

            }

            return tasks;

        }



        /// <summary>

        /// Wait All done Event

        /// </summary>

        /// <param name="doneEvents"></param>

        private void WaitAll(WaitHandle[] doneEvents)

        {



            // WaitAll for multiple handles on an STA thread is not supported.

            // so wait on each handle individually.

            if (Thread.CurrentThread.GetApartmentState() == ApartmentState.STA)

            {

                // using foreach，wait for each Thread

                foreach (WaitHandle myWaitHandle in doneEvents)

                {

                    WaitHandle.WaitAny(new WaitHandle[] { myWaitHandle });

                }

            }

            else

            {

                WaitHandle.WaitAll(doneEvents);

            }



        }

下面在说说可爱的java,很简单，因为都已经封装好了。



public final class MutipThread {

    public static void main(String[] args) {



        List<Task> tasks = new ArrayList<Task>(task_num);

	for (int index = 0; index < task_num; index++) {

	    tasks.add(new Task(....));

	}



        ExecutorService threadPoolService = null;

        try {

                threadPoolService = Executors.newFixedThreadPool(thread_num);

                List<Future<Object>> futures = threadPoolService.invokeAll(downloadTasks);

                for (Future<Object> future : futures) {

                    System.out.println(future.get());

                }

        } finally {

            if (threadPoolService != null) {

                threadPoolService.shutdown();

            }



        }

    }



    static class Task implements Callable<Object> {

        public Object call() throws Exception {

            // do something

	}

    }

}