জাভা 8 লাম্বদা ফাংশন যে ব্যতিক্রম ছুঁড়ে?


469

আমি জানি যে কীভাবে একটি Stringপ্যারামিটার রয়েছে এমন কোনও পদ্ধতির একটি রেফারেন্স তৈরি করতে হবে এবং intএটির জন্য ফেরত দেয় , এটি:

Function<String, Integer>

যাইহোক, যদি ফাংশনটি একটি ব্যতিক্রম ছুঁড়ে ফেলে তবে এটি কাজ করে না, বলুন এটির হিসাবে এটি সংজ্ঞায়িত হয়েছে:

Integer myMethod(String s) throws IOException

আমি এই রেফারেন্সটি কীভাবে সংজ্ঞায়িত করব?





4
সমস্ত সমাধানটি দেখতে কিছুটা দেখতে কেমন লাগে, রানটাইম ব্যতিক্রমগুলি ছুঁড়ে দেওয়া, আমি বিশ্বাস করি এটি কোনও ভাল সমাধান নয়। লুপগুলির জন্য পুরানো জাভা ব্যবহার করা আরও ভাল
নাজিল

5
মুল গ্রন্থাগার সম্পর্কে কী ? সিএফ org.jooq.lambda. অচিহ্নিত প্যাকেজ
ছায়াছাইয়া

উত্তর:


400

আপনাকে নিম্নলিখিতগুলির একটি করতে হবে।

  • যদি এটি আপনার কোড হয় তবে আপনার নিজের ক্রিয়ামূলক ইন্টারফেসটি সংজ্ঞায়িত করুন যা পরীক্ষিত ব্যতিক্রম ঘোষণা করে:

    @FunctionalInterface
    public interface CheckedFunction<T, R> {
       R apply(T t) throws IOException;
    }

    এবং এটি ব্যবহার করুন:

    void foo (CheckedFunction f) { ... }
  • অন্যথায়, Integer myMethod(String s)এমন কোনও পদ্ধতিতে মোড়ানো যা পরীক্ষিত ব্যতিক্রম ঘোষণা করে না:

    public Integer myWrappedMethod(String s) {
        try {
            return myMethod(s);
        }
        catch(IOException e) {
            throw new UncheckedIOException(e);
        }
    }

    এবং তারপর:

    Function<String, Integer> f = (String t) -> myWrappedMethod(t);

    বা:

    Function<String, Integer> f =
        (String t) -> {
            try {
               return myMethod(t);
            }
            catch(IOException e) {
                throw new UncheckedIOException(e);
            }
        };

7
আপনি প্রকৃতপক্ষে প্রসারিত করতে পারেন Consumerবা Functionযদি আপনি ডিফল্ট পদ্ধতি ব্যবহার করেন - নীচে আমার উত্তরটি দেখুন।
jlb

2
আমি মনে করি এটি ওয়ান-লাইনার হিসাবে সম্পন্ন করা যেতে পারে ।
নেড টিগিগ

6
গৌণ অপ্টিমাইজেশন: পরিবর্তে (String t) -> myWrappedMethod(t), পদ্ধতি রেফারেন্সও this::myWrappedMethodব্যবহার করা যেতে পারে।
ক্লাশসফট

8
এটি করার আরও একটি সাধারণ উপায় হ'ল এই @FunctionalInterface পাবলিক ইন্টারফেসের মতো পরীক্ষিত ফাংশনটি সংজ্ঞায়িত করা চেকড ফাংশন <টি, আর, ই ব্যতিক্রম ব্যতিক্রম> apply আর প্রয়োগ (টি টি) ই ছুড়ে; That এই পদ্ধতিতে আপনি কোনও ব্যতিক্রমটি যে নিক্ষেপ করছে তা নির্ধারণ করতে পারেন এবং কোনও কোডের জন্য ইন্টারফেসটি পুনরায় ব্যবহার করতে পারেন।
মার্টিন ওধেলিয়াস

3
কি দারুন. জাভা আমার
ভাবার

194

আপনি জাভা 8 এর ডিফল্ট পদ্ধতি ব্যবহার করে - ব্যতিক্রমগুলি পরিচালনা করে এমন একটি নতুন ইন্টারফেস দিয়ে প্রকৃতপক্ষে প্রসারিত করতে পারেন Consumer(এবং Functionইত্যাদি) !

এই ইন্টারফেস বিবেচনা করুন (প্রসারিত Consumer):

@FunctionalInterface
public interface ThrowingConsumer<T> extends Consumer<T> {

    @Override
    default void accept(final T elem) {
        try {
            acceptThrows(elem);
        } catch (final Exception e) {
            // Implement your own exception handling logic here..
            // For example:
            System.out.println("handling an exception...");
            // Or ...
            throw new RuntimeException(e);
        }
    }

    void acceptThrows(T elem) throws Exception;

}

তারপরে, উদাহরণস্বরূপ, যদি আপনার একটি তালিকা থাকে:

final List<String> list = Arrays.asList("A", "B", "C");

আপনি যদি forEachব্যতিক্রম ছুঁড়ে এমন কিছু কোড দিয়ে এটি (উদাহরণস্বরূপ ) গ্রাস করতে চান তবে আপনি traditionতিহ্যগতভাবে একটি চেষ্টা / ক্যাপ ব্লক সেটআপ করে দিতেন:

final Consumer<String> consumer = aps -> {
    try {
        // maybe some other code here...
        throw new Exception("asdas");
    } catch (final Exception ex) {
        System.out.println("handling an exception...");
    }
};
list.forEach(consumer);

তবে এই নতুন ইন্টারফেসের সাহায্যে আপনি ল্যাম্বডা এক্সপ্রেশন দিয়ে তা ইনস্ট্যান্ট করতে পারেন এবং সংকলকটি অভিযোগ করবে না:

final ThrowingConsumer<String> throwingConsumer = aps -> {
    // maybe some other code here...
    throw new Exception("asdas");
};
list.forEach(throwingConsumer);

বা এমনকি এটি আরও সাবলীল হতে কাস্ট করুন !:

list.forEach((ThrowingConsumer<String>) aps -> {
    // maybe some other code here...
    throw new Exception("asda");
});

আপডেট : দেখে মনে হচ্ছে ডুরিয়ানের একটি দুর্দান্ত ইউটিলিটি লাইব্রেরির অংশ রয়েছে যার নাম ত্রুটি যা আরও অনেক নমনীয়তার সাথে এই সমস্যাটি সমাধান করতে ব্যবহার করা যেতে পারে। উদাহরণস্বরূপ, উপরের আমার বাস্তবায়নে আমি ত্রুটি পরিচালনার নীতি ( System.out...বা throw RuntimeException) স্পষ্টভাবে সংজ্ঞায়িত করেছি , যেখানে ডুরিয়ানের ত্রুটিগুলি আপনাকে ইউটিলিটি পদ্ধতির একটি বড় স্যুটের মাধ্যমে ফ্লাইতে একটি নীতি প্রয়োগ করতে দেয়। এটি ভাগ করার জন্য ধন্যবাদ , @ নেডটিউইগ !.

নমুনা ব্যবহার:

list.forEach(Errors.rethrow().wrap(c -> somethingThatThrows(c)));

14
সুতরাং আপনার কাছে ইন্টারফেসের একটি সেট রয়েছে (ফাংশন, কনজিউমার, সাপ্লায়ার, ...) এবং ত্রুটিগুলি পরিচালনা করার জন্য নীতিগুলির একটি সেট (নিক্ষেপ, System.out.println, ...)। আমার মনে হয় "থ্রোইংকেনমার, থ্রোং ফাংশন" ইত্যাদি পেস্ট অনুলিপি না করে কোনও ধরণের ফাংশন দিয়ে কোনও নীতি ব্যবহার করা সহজ করার একটি উপায় আছে।
নেড টিগিগ

1
কিছু সময় পরে ... আমি চেক করা ব্যতিক্রমগুলি ব্যবহার করার এবং কোনও অতিরিক্ত ক্রিয়ামূলক ইন্টারফেস বা নতুন লাইব্রেরি ব্যবহার না করার সিদ্ধান্ত নিয়েছি -> সহজ রাস্তা, কম টাইপিং, দ্রুত ডেলিভারি, তাই না।
আলিওপি

1
চুরির ছোঁড়া আইডিয়াম ব্যবহার করে এখানে একটি উন্নত সংস্করণ দেওয়া আছে । রানটাইম এক্সসেপশনটিকে চেকএক্সসেপশন-এ মোড়ক করার দরকার নেই।
মিউই ২

61

আমি মনে করি ডুরিয়ান Errorsশ্রেণি উপরোক্ত বিভিন্ন পরামর্শের অনেকগুলি সমন্বয় করেছে।

আপনার প্রকল্পে ডুরিয়ানকে অন্তর্ভুক্ত করতে আপনি যা করতে পারেন:


অথবা আপনি কেবল আরএক্সজাভা ব্যবহার করতে পারেন যেহেতু স্ট্রিমগুলির অন্তর্নিহিত ত্রুটি পরিচালনার প্রয়োজন হয় এবং আপনার পাইপলাইনে যদি কিছু ব্যতিক্রম হয় তবে এটি সম্ভবত একটি পর্যবেক্ষণযোগ্য স্ট্রিম হওয়ার সম্ভাবনা রয়েছে। এটি কোনও লাইব্রেরির ডাউনস্ট্রিম গ্রাহকদের জন্য জাভা 8 জোর করে না।
অ্যাডাম জেন্ট 18

2
দয়া করে নোট করুন যে জুন ২০১ 2016 সাল থেকে ডুরিয়ানের কোনও নতুন সংস্করণ নেই a শো স্টপার নয়, কিছু মনে রাখবেন।
ইস্তান দেওয়াই

9
এখানে ডুরিয়ান রক্ষণাবেক্ষণকারী। কি ভেঙে গেছে? যদি কোনও ব্যবহারকারী কোনও ত্রুটি বা কোনও গুরুত্বপূর্ণ অনুপস্থিত বৈশিষ্ট্য খুঁজে পায় তবে আমরা দ্রুত একটি বাগফিক্স প্রকাশ করব। লাইব্রেরিটি সহজ, সুতরাং আমাদের কাছে কোনও বাগ রিপোর্ট নেই, সুতরাং আমাদের কোনও বাগফিক্স প্রকাশ করার দরকার নেই।
নেড টিগিগ

28

এটি জাভা ৮ এর সাথে নির্দিষ্ট নয় You আপনি এর সমতুল্য কিছু সংকলনের চেষ্টা করছেন:

interface I {
    void m();
}
class C implements I {
    public void m() throws Exception {} //can't compile
}

15
প্রশ্নটি হল "আমি কীভাবে এই রেফারেন্সটি সংজ্ঞায়িত করব?" । এটি আসলে প্রশ্নের উত্তর দেয় না; সমস্যাটি কী তা এটি কেবল ব্যাখ্যা করে।
দাউদ ইবনে কেরেম

13

দাবি অস্বীকার: আমি এখনও জাভা 8 ব্যবহার করি নি, কেবল এটি সম্পর্কে পড়ি।

Function<String, Integer>নিক্ষেপ IOExceptionকরবে না, যাতে আপনি এতে কোনও কোড রাখতে পারবেন না throws IOException। যদি আপনি এমন কোনও পদ্ধতি কল করে যা একটি আশা করে Function<String, Integer>, তবে সেই পদ্ধতিতে আপনি যে ল্যাম্বদাটি পাস করেছেন তা ছুড়ে দিতে পারে না IOExceptionperiod আপনি হয় এইভাবে একটি ল্যাম্বদা লিখতে পারেন (আমি মনে করি এটি ল্যাম্বডা সিনট্যাক্স, নিশ্চিত নয়):

(String s) -> {
    try {
        return myMethod(s);
    } catch (IOException ex) {
        throw new RuntimeException(ex);
        // (Or do something else with it...)
    }
}

বা, আপনি যে পদ্ধতিতে ল্যাম্বদাটি পাস করছেন তা যদি আপনি নিজে লিখেছেন তবে আপনি একটি নতুন কার্যকরী ইন্টারফেসটি সংজ্ঞায়িত করতে পারেন এবং সেইটিকে পরামিতি প্রকারের পরিবর্তে ব্যবহার করতে পারেন Function<String, Integer>:

public interface FunctionThatThrowsIOException<I, O> {
    O apply(I input) throws IOException;
}

আপনার ইন্টারফেসের আগে @FunctionalInterface টিকা যোগ করুন, তবেই এটি ল্যাম্বডাসের জন্য ব্যবহারযোগ্য হবে।
গাংনাস

13
@ গাংনাস: @FunctionalInterfaceটীকাগুলি ল্যাম্বডাসের জন্য ব্যবহারযোগ্য হওয়ার জন্য এটির প্রয়োজন নেই। যদিও এটি স্যানিটি পরীক্ষা করার জন্য প্রস্তাবিত।
তন্ময় পাতিল

9

আপনি যদি কোনও তৃতীয় পক্ষের lib ( Vavr ) ব্যবহার করতে আপত্তি করেন না তবে আপনি লিখতে পারেন

CheckedFunction1<String, Integer> f = this::myMethod;

এটিতে তথাকথিত ট্রাই মনোড রয়েছে যা ত্রুটিগুলি পরিচালনা করে:

Try(() -> f.apply("test")) // results in a Success(Integer) or Failure(Throwable)
        .map(i -> ...) // only executed on Success
        ...

এখানে আরও পড়ুন ।

দাবি অস্বীকার: আমি ভ্যাবরের স্রষ্টা।



6

তবে আপনি নিজের ফাংশনাল ইন্টারফেসটি তৈরি করতে পারেন যা নীচের মত ছুঁড়েছে ..

@FunctionalInterface
public interface UseInstance<T, X extends Throwable> {
  void accept(T instance) throws X;
}

তারপরে নীচে প্রদর্শিত হিসাবে ল্যাম্বডাস বা রেফারেন্স ব্যবহার করে এটি বাস্তবায়ন করুন।

import java.io.FileWriter;
import java.io.IOException;

//lambda expressions and the execute around method (EAM) pattern to
//manage resources

public class FileWriterEAM  {
  private final FileWriter writer;

  private FileWriterEAM(final String fileName) throws IOException {
    writer = new FileWriter(fileName);
  }
  private void close() throws IOException {
    System.out.println("close called automatically...");
    writer.close();
  }
  public void writeStuff(final String message) throws IOException {
    writer.write(message);
  }
  //...

  public static void use(final String fileName, final UseInstance<FileWriterEAM, IOException> block) throws IOException {

    final FileWriterEAM writerEAM = new FileWriterEAM(fileName);    
    try {
      block.accept(writerEAM);
    } finally {
      writerEAM.close();
    }
  }

  public static void main(final String[] args) throws IOException {

    FileWriterEAM.use("eam.txt", writerEAM -> writerEAM.writeStuff("sweet"));

    FileWriterEAM.use("eam2.txt", writerEAM -> {
        writerEAM.writeStuff("how");
        writerEAM.writeStuff("sweet");      
      });

    FileWriterEAM.use("eam3.txt", FileWriterEAM::writeIt);     

  }


 void writeIt() throws IOException{
     this.writeStuff("How ");
     this.writeStuff("sweet ");
     this.writeStuff("it is");

 }

}

6

আপনি পারেন।

@ মার্কস এর প্রসারিত করা UtilExceptionএবং <E extends Exception>যেখানে প্রয়োজন সেখানে জেনেরিক যুক্ত করা: এইভাবে সংকলকটি আপনাকে আবার থ্রো ক্লজ এবং সমস্ত কিছু যুক্ত করতে বাধ্য করবে যেন আপনি জাভা 8 এর স্ট্রিমগুলিতে চেক করা ব্যতিক্রমগুলি স্থানীয়ভাবে ছুঁড়ে ফেলতে পারেন।

public final class LambdaExceptionUtil {

    @FunctionalInterface
    public interface Function_WithExceptions<T, R, E extends Exception> {
        R apply(T t) throws E;
    }

    /**
     * .map(rethrowFunction(name -> Class.forName(name))) or .map(rethrowFunction(Class::forName))
     */
    public static <T, R, E extends Exception> Function<T, R> rethrowFunction(Function_WithExceptions<T, R, E> function) throws E  {
        return t -> {
            try {
                return function.apply(t);
            } catch (Exception exception) {
                throwActualException(exception);
                return null;
            }
        };
    }

    @SuppressWarnings("unchecked")
    private static <E extends Exception> void throwActualException(Exception exception) throws E {
        throw (E) exception;
    }

}

public class LambdaExceptionUtilTest {

    @Test
    public void testFunction() throws MyTestException {
        List<Integer> sizes = Stream.of("ciao", "hello").<Integer>map(rethrowFunction(s -> transform(s))).collect(toList());
        assertEquals(2, sizes.size());
        assertEquals(4, sizes.get(0).intValue());
        assertEquals(5, sizes.get(1).intValue());
    }

    private Integer transform(String value) throws MyTestException {
        if(value==null) {
            throw new MyTestException();
        }
        return value.length();
    }

    private static class MyTestException extends Exception { }
}

5

আমি ক্লাস.ফরনাম এবং ক্লাস.নেউ ইনস্ট্যান্সের সাথে একটি ল্যাম্বডায় অভ্যস্ত ছিলাম, তাই আমি ঠিক করেছি:

public Object uncheckedNewInstanceForName (String name) {

    try {
        return Class.forName(name).newInstance();
    }
    catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
        throw new RuntimeException(e);
    }
}

Class.forName ("myClass") কল করার পরিবর্তে ল্যাম্বদার ভিতরে new


4

ফাংশন র‌্যাপার ব্যবহার করে অন্য একটি সমাধান হ'ল হয় আপনার ফলাফলের একটি মোড়কের একটি উদাহরণ ফিরে আসা, সাফল্য বলুন, যদি সবকিছু ঠিকঠাক হয় তবে হয় উদাহরণস্বরূপ, ব্যর্থতা বলুন।

বিষয়গুলি পরিষ্কার করার জন্য কিছু কোড:

public interface ThrowableFunction<A, B> {
    B apply(A a) throws Exception;
}

public abstract class Try<A> {

    public static boolean isSuccess(Try tryy) {
        return tryy instanceof Success;
    }

    public static <A, B> Function<A, Try<B>> tryOf(ThrowableFunction<A, B> function) {
        return a -> {
            try {
                B result = function.apply(a);
                return new Success<B>(result);
            } catch (Exception e) {
                return new Failure<>(e);
            }
        };
    }

    public abstract boolean isSuccess();

    public boolean isError() {
        return !isSuccess();
    }

    public abstract A getResult();

    public abstract Exception getError();
}

public class Success<A> extends Try<A> {

    private final A result;

    public Success(A result) {
        this.result = result;
    }

    @Override
    public boolean isSuccess() {
        return true;
    }

    @Override
    public A getResult() {
        return result;
    }

    @Override
    public Exception getError() {
        return new UnsupportedOperationException();
    }

    @Override
    public boolean equals(Object that) {
        if(!(that instanceof Success)) {
            return false;
        }
        return Objects.equal(result, ((Success) that).getResult());
    }
}

public class Failure<A> extends Try<A> {

    private final Exception exception;

    public Failure(Exception exception) {
        this.exception = exception;
    }

    @Override
    public boolean isSuccess() {
        return false;
    }

    @Override
    public A getResult() {
        throw new UnsupportedOperationException();
    }

    @Override
    public Exception getError() {
        return exception;
    }
}

একটি সাধারণ ব্যবহারের কেস:

List<Try<Integer>> result = Lists.newArrayList(1, 2, 3).stream().
    map(Try.<Integer, Integer>tryOf(i -> someMethodThrowingAnException(i))).
    collect(Collectors.toList());

4

এই সমস্যাটি আমাকেও বিরক্ত করছে; এই কারণেই আমি এই প্রকল্পটি তৈরি করেছি ।

এটি দিয়ে আপনি এটি করতে পারেন:

final ThrowingFunction<String, Integer> f = yourMethodReferenceHere;

জেডিকে দ্বারা সংজ্ঞায়িত 39 টি ইন্টারফেসের টোটলা রয়েছে যা এর Throwingসমতুল্য; এগুলি সব @FunctionalInterfaceস্ট্রিমে ব্যবহৃত হয় (বেস Streamতবে IntStream, LongStreamএবংDoubleStream )।

এবং তাদের প্রত্যেকে যেমন তাদের নিক্ষেপকারী অংশকে বাড়িয়েছে, আপনি এগুলি সরাসরি ল্যাম্বডাসেও ব্যবহার করতে পারেন:

myStringStream.map(f) // <-- works

ডিফল্ট আচরণটি হ'ল যখন আপনার নিক্ষেপকারী ল্যাম্বদা একটি পরীক্ষিত ব্যতিক্রম ThrownByLambdaExceptionছুঁড়ে ফেলে , তখন কারণ হিসাবে চেক করা ব্যতিক্রম সহ একটি নিক্ষেপ করা হয়। সুতরাং আপনি এটি ক্যাপচার এবং কারণ পেতে পারেন।

অন্যান্য বৈশিষ্ট্যগুলিও উপলব্ধ।


আমি সত্যিই এই ধারণাটি পছন্দ করি, কেবলমাত্র আপনি এখানে পরামর্শ অনুসারে নিক্ষেপযোগ্যদের জেনেরিক করে তুলবেন: javasp विशेषज्ञists.eu/archive/Issue221.html , উদাহরণস্বরূপ: @FunctionalInterface public interface SupplierWithCE<T, X extends Exception> { T get() throws X; }- এইভাবে ব্যবহারকারীকে ধরার দরকার নেই Throwable, তবে তার পরিবর্তে নির্দিষ্ট পরীক্ষিত ব্যতিক্রম।
জোল্টন

@ জোল্টন যদিও প্রতিবারই ব্যতিক্রম ঘোষণা করতে ব্যথা হবে; এছাড়াও, আপনি সবসময় ঠিক ব্যবহার করতে পারেন, .apply বলে () পরিবর্তে .doApply () এবং ছিটকিনি এর ThrownByLambdaException, আপনি একটি কারণ বলে মূল ব্যতিক্রম হবে (অথবা আপনি ব্যবহার করতে পারেন rethrow(...).as(MyRuntimeException.class))
fge

আমি মনে করি এর চারপাশে একটি ( উপায় ) আছে ।
নেড টিগিগ

@ নেডটিগিগ আমি এটিও অনেক আগে সমাধান করেছি; আমি এখন Throwing.runnable()এবং অন্যদের, সর্বদা শৃঙ্খলাবদ্ধ ক্ষমতা সহ ব্যবহার করতে পারি
fge

চেইন কার্যকারিতা খুব দুর্দান্ত! আমার মন্তব্য থ্রয়েংআরনেবলের সাধারণ ব্যতিক্রম হওয়া উচিত কিনা তা নিয়ে ছিল was জোলটান জিজ্ঞাসা করেছিল যে আপনার লাইব্রেরিতে জেনেরিক প্যারামিটার হিসাবে যুক্তি থাকতে পারে এবং আপনি বলেছিলেন যে এটি ব্যবহারে ব্যথা হবে। আমার লিঙ্কটি কোডের কয়েকটি লাইনে ছিল যা ব্যথা না হয়ে ব্যতিক্রমগুলি জেনেরিক হওয়ার এক উপায় দেখায়। আমি এটির অপ্রত্যাশিত না হলে আপনার লাইব্রেরিতে ব্যতিক্রমগুলি জেনেরিক হয় না (এটি একটি যুক্তিসঙ্গত নকশার পছন্দ, কারণ এগুলি জেনেরিক করে আপনি খুব বেশি উপযোগিতা পান না)।
নেড টিগিগ

4

ইতিমধ্যে এখানে পোস্ট করা প্রচুর প্রতিক্রিয়া রয়েছে। সমস্যাটিকে ভিন্ন দৃষ্টিকোণ দিয়ে সমাধান করার চেষ্টা করছি। এটি মাত্র আমার 2 সেন্ট, আমি কোথাও ভুল হলে দয়া করে আমাকে সংশোধন করুন।

ফাংশনাল ইনটারফেসে ক্লোজ নিক্ষেপ করা ভাল ধারণা নয়

আমি মনে করি নিম্নলিখিত কারণগুলির কারণে থ্রো আইওএক্সসেপশন প্রয়োগ করা সম্ভবত এটি ভাল ধারণা নয়

  • এটি আমার কাছে স্ট্রিম / ল্যাম্বডায় একটি অ্যান্টি-প্যাটার্নের মতো দেখাচ্ছে। পুরো ধারণাটি হ'ল কলার কী কোড সরবরাহ করবেন এবং কীভাবে ব্যতিক্রম পরিচালনা করবেন তা সিদ্ধান্ত নেবে। অনেক পরিস্থিতিতে, ক্লায়েন্টের জন্য আইওএক্সেপশন প্রযোজ্য নাও হতে পারে। উদাহরণস্বরূপ, যদি ক্লায়েন্ট প্রকৃত I / O সম্পাদন করার পরিবর্তে ক্যাশে / মেমরির থেকে মান অর্জন করে।

  • এছাড়াও, স্ট্রিমগুলিতে পরিচালনা করা ব্যতিক্রমগুলি সত্যই ঘৃণ্য হয়ে ওঠে। উদাহরণস্বরূপ, এখানে আমি আপনার এপিআই ব্যবহার করি তবে আমার কোডটি এমন দেখাচ্ছে

               acceptMyMethod(s -> {
                    try {
                        Integer i = doSomeOperation(s);
                        return i;
                    } catch (IOException e) {
                        // try catch block because of throws clause
                        // in functional method, even though doSomeOperation
                        // might not be throwing any exception at all.
                        e.printStackTrace();
                    }
                    return null;
                });

    কুরুচি তাই না? তদুপরি, আমি আমার প্রথম পয়েন্টে উল্লেখ করেছি যে, doSomeOperation পদ্ধতি আইওএক্সেপশন (ক্লায়েন্ট / কলারের প্রয়োগের উপর নির্ভর করে) নিক্ষেপ করতে পারে বা নাও পারে, তবে আপনার ফাংশনাল ইনটারফেস পদ্ধতিতে নিক্ষিপ্ত ধারাটির কারণে আমাকে সর্বদা লিখতে হবে ধরার চেষ্টা কর.

আমি যদি সত্যিই এই API টি আইওএক্সসেপশনকে ছুড়ে ফেলে জানতাম তবে আমি কী করব

  • তারপরে সম্ভবত আমরা সাধারণত ইন্টারফেসের সাথে ফাংশনাল ইন্টারফেসকে বিভ্রান্ত করছি। আপনি যদি জানেন যে এই API টি IOException নিক্ষেপ করবে, তবে সম্ভবত আপনি কিছু ডিফল্ট / বিমূর্ত আচরণও জানেন। আমি মনে করি আপনার একটি ইন্টারফেস সংজ্ঞায়িত করা উচিত এবং আপনার লাইব্রেরিটি নিম্নলিখিত (ডিফল্ট / বিমূর্ত প্রয়োগ সহ) স্থাপন করা উচিত y

    public interface MyAmazingAPI {
        Integer myMethod(String s) throws IOException;
    }

    তবে, ক্লায়েন্টের জন্য ট্রাই-ক্যাচ সমস্যাটি এখনও বিদ্যমান। যদি আমি আপনার এপিআই প্রবাহে ব্যবহার করি তবে আমার এখনও আইওএক্সেপশন হ্যান্ডসেল করা দরকার গোপনীয় ট্রাই-ক্যাচ ব্লকে।

  • নিম্নলিখিত হিসাবে একটি ডিফল্ট স্ট্রিম-বান্ধব API সরবরাহ করুন

    public interface MyAmazingAPI {
        Integer myMethod(String s) throws IOException;
    
        default Optional<Integer> myMethod(String s, Consumer<? super Exception> exceptionConsumer) {
            try {
                return Optional.ofNullable(this.myMethod(s));
            } catch (Exception e) {
                if (exceptionConsumer != null) {
                    exceptionConsumer.accept(e);
                } else {
                    e.printStackTrace();
                }
            }
    
            return Optional.empty();
        }
    }

    ডিফল্ট পদ্ধতিটি গ্রাহক বস্তুকে যুক্তি হিসাবে গ্রহণ করে, যা ব্যতিক্রমটি পরিচালনা করতে দায়বদ্ধ হবে be এখন, ক্লায়েন্টের দৃষ্টিকোণ থেকে কোডটি এর মতো দেখাবে

    strStream.map(str -> amazingAPIs.myMethod(str, Exception::printStackTrace))
                    .filter(Optional::isPresent)
                    .map(Optional::get).collect(toList());

    ঠিক আছে? অবশ্যই, লগার বা অন্যান্য হ্যান্ডলিং যুক্তি ব্যতিক্রম ব্যতীত :: মুদ্রণস্ট্যাকট্রেসের পরিবর্তে ব্যবহৃত হতে পারে।

  • আপনি https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/CompletableFचर . html#exceptionally-java.util.function.Function- এর অনুরূপ একটি পদ্ধতিও প্রকাশ করতে পারেন । এর অর্থ আপনি অন্য পদ্ধতিটি প্রকাশ করতে পারবেন, এতে আগের পদ্ধতি কল থেকে ব্যতিক্রম থাকবে। অসুবিধাটি হ'ল আপনি এখন আপনার এপিআইগুলিকে রাষ্ট্রীয় করে তুলছেন, যার অর্থ আপনার থ্রেড-সুরক্ষা পরিচালনা করতে হবে এবং যা শেষ পর্যন্ত পারফরম্যান্স হিট হয়ে উঠবে। বিবেচনা করার জন্য কেবল একটি বিকল্প।


আমি সম্মত হই যে চেক করা ব্যতিক্রমটিকে একটি চেক করা ব্যতিক্রম হিসাবে রূপান্তর করা, বা ব্যতিক্রমটিকে গ্রাস করা ভাল ধারণা নয় কারণ Streamউত্থাপিত কোন উপাদানটি ব্যতিক্রম উত্থাপিত হয়েছে তা জানার উপায় নেই । সুতরাং, আমি একটি ব্যতিক্রম হ্যান্ডলার থাকার ধারণাটি পছন্দ করি যা বৈধ নয়। মনে রাখবেন যে আপনার মাইআমজিংএপিআই কার্যকরভাবে একটি FunctionalInterface(তাই আপনি @ ফাংশনাল ইনটারফেস টীকা যোগ করতে পারেন)। এছাড়াও আপনার ব্যবহারের পরিবর্তে একটি ডিফল্ট মান থাকতে পারে Optional.empty()
জুলিয়েন ক্রোনেগ

4

লুক্কায়িত থ্রো আইডিয়মCheckedException লাম্বদা এক্সপ্রেশনকে বাইপাস করে সক্ষম করে । একটি মোড়ানো CheckedExceptionএকটি RuntimeExceptionকঠোর ত্রুটি পরিচালনা জন্য ভাল নয়।

এটি Consumerএকটি জাভা সংগ্রহে ব্যবহৃত একটি ফাংশন হিসাবে ব্যবহার করা যেতে পারে ।

জিবের উত্তরের একটি সহজ এবং উন্নত সংস্করণ এখানে ।

import static Throwing.rethrow;

@Test
public void testRethrow() {
    thrown.expect(IOException.class);
    thrown.expectMessage("i=3");

    Arrays.asList(1, 2, 3).forEach(rethrow(e -> {
        int i = e.intValue();
        if (i == 3) {
            throw new IOException("i=" + i);
        }
    }));
}

এটি কেবল পুনরায় একটি ল্যাম্বডাকে জড়িয়ে দেয় । এটি আপনার ল্যাম্বডায় ফেলে দেওয়া যে CheckedExceptionকোনওটিকে পুনর্বিবেচনা করে তোলে Exception

public final class Throwing {
    private Throwing() {}

    @Nonnull
    public static <T> Consumer<T> rethrow(@Nonnull final ThrowingConsumer<T> consumer) {
        return consumer;
    }

    /**
     * The compiler sees the signature with the throws T inferred to a RuntimeException type, so it
     * allows the unchecked exception to propagate.
     * 
     * http://www.baeldung.com/java-sneaky-throws
     */
    @SuppressWarnings("unchecked")
    @Nonnull
    public static <E extends Throwable> void sneakyThrow(@Nonnull Throwable ex) throws E {
        throw (E) ex;
    }

}

একটি সম্পূর্ণ কোড এবং ইউনিট পরীক্ষা এখানে সন্ধান করুন


3

আপনি এটির জন্য ইটি ব্যবহার করতে পারেন । ব্যতিক্রম রূপান্তর / অনুবাদের জন্য ইটি একটি ছোট জাভা 8 লাইব্রেরি।

ET এর সাথে এটির মতো দেখাচ্ছে:

// Do this once
ExceptionTranslator et = ET.newConfiguration().done();

...

// if your method returns something
Function<String, Integer> f = (t) -> et.withReturningTranslation(() -> myMethod(t));

// if your method returns nothing
Consumer<String> c = (t) -> et.withTranslation(() -> myMethod(t));

ExceptionTranslatorউদাহরণগুলি থ্রেড নিরাপদ একটি একাধিক উপাদান দ্বারা ভাগ করা যায়। আপনি FooCheckedException -> BarRuntimeExceptionযদি চান তবে আপনি আরও নির্দিষ্ট ব্যতিক্রম রূপান্তর বিধি (যেমন ) কনফিগার করতে পারেন। যদি অন্য কোনও নিয়ম উপলব্ধ না হয় তবে চেক করা ব্যতিক্রমগুলি স্বয়ংক্রিয়ভাবে রূপান্তরিত হয় RuntimeException

(অস্বীকৃতি: আমি ইটির লেখক)


2
দেখে মনে হচ্ছে আপনি এই লাইব্রেরির লেখক। এসও বিধি মোতাবেক আপনার উত্তরগুলিতে আপনাকে অবশ্যই অনুমোদিততা প্রকাশ করতে হবে । আপনি এই লাইব্রেরিটি লিখেছেন এমন আপনার উত্তরটিতে স্পষ্টভাবে যুক্ত করুন (অন্যান্য ইটি সম্পর্কিত উত্তরগুলির জন্য একই)।
তাগীর ভালিভ

2
হাই তাগীর, ইঙ্গিতটির জন্য ধন্যবাদ। আমি উত্তর আপডেট।
মিচা

2

আমি যা করছি তা হ'ল ব্যতিক্রমের ক্ষেত্রে ব্যবহারকারীকে তার পছন্দসই মূল্য দিতে দেওয়া। সুতরাং আমি কিছু এই মত দেখাচ্ছে

public static <T, R> Function<? super T, ? extends R> defaultIfThrows(FunctionThatThrows<? super T, ? extends R> delegate, R defaultValue) {
    return x -> {
        try {
            return delegate.apply(x);
        } catch (Throwable throwable) {
            return defaultValue;
        }
    };
}

@FunctionalInterface
public interface FunctionThatThrows<T, R> {
    R apply(T t) throws Throwable;
}

এবং এটির পরে কল হতে পারে:

defaultIfThrows(child -> child.getID(), null)

1
এটি এই ধারণার এক্সটেনশন যা "ডিফল্ট মান" কৌশল (আপনার উত্তর হিসাবে) এবং "পুনর্বার রানটাইম এক্সেকশন" কৌশল, যেখানে একটি ডিফল্ট মান প্রয়োজন হয় না তার মধ্যে পার্থক্য তৈরি করে।
নেড টিগিগ

2

আপনার যদি আমি তৃতীয় পক্ষের লাইব্রেরিটি ব্যবহার করতে আপত্তি না জানি তবে সাইক্লোপস- রিএ্যাক্ট , আমি যে লাইব্রেরিতে অবদান রাখছি আপনি লিখতে ফ্লুয়েন্ট ফাংশনস এপিআই ব্যবহার করতে পারেন

 Function<String, Integer> standardFn = FluentFunctions.ofChecked(this::myMethod);

অফ চেকড একটি জুইউλ চেকড ফাংশন নেয় এবং রেফারেন্সটি নরম হয়ে স্ট্যান্ডার্ড (চেক না করা) জেডিকে java.util.function.Function এ ফিরিয়ে দেয়।

বিকল্পভাবে আপনি ফ্লুয়েটফিউশনস এপিআইয়ের মাধ্যমে ক্যাপচারিত ফাংশনটির সাথে কাজ চালিয়ে যেতে পারেন!

উদাহরণস্বরূপ, আপনার পদ্ধতিটি কার্যকর করার জন্য, এটি 5 বার পর্যন্ত পুনরায় চেষ্টা করা এবং এটির স্থিতি লগ করা আপনি লিখতে পারেন

  FluentFunctions.ofChecked(this::myMethod)
                 .log(s->log.debug(s),e->log.error(e,e.getMessage())
                 .try(5,1000)
                 .apply("my param");

2

ডিফল্টরূপে, জাভা 8 ফাংশনটি ব্যতিক্রম ছোঁড়ার অনুমতি দেয় না এবং একাধিক উত্তরে যেমন এটি অর্জনের অনেকগুলি উপায় রয়েছে তেমন পরামর্শ দেওয়া হয়েছে, একটি উপায়:

@FunctionalInterface
public interface FunctionWithException<T, R, E extends Exception> {
    R apply(T t) throws E;
}

হিসাবে সংজ্ঞায়িত করুন:

private FunctionWithException<String, Integer, IOException> myMethod = (str) -> {
    if ("abc".equals(str)) {
        throw new IOException();
    }
  return 1;
};

এবং কলার পদ্ধতিতে যুক্ত throwsবা try/catchএকই ব্যতিক্রম।


2

একটি কাস্টম রিটার্ন টাইপ তৈরি করুন যা পরীক্ষিত ব্যতিক্রম প্রচার করবে। এটি একটি নতুন ইন্টারফেস তৈরির বিকল্প যা কার্যকরী ইন্টারফেসের পদ্ধতিতে "থ্রো ব্যতিক্রম" এর সামান্য পরিবর্তন সহ বিদ্যমান ফাংশনাল ইন্টারফেসকে আয়না করে।

সংজ্ঞা

CheckedValueSupplier

public static interface CheckedValueSupplier<V> {
    public V get () throws Exception;
}

CheckedValue

public class CheckedValue<V> {
    private final V v;
    private final Optional<Exception> opt;

    public Value (V v) {
        this.v = v;
    }

    public Value (Exception e) {
        this.opt = Optional.of(e);
    }

    public V get () throws Exception {
        if (opt.isPresent()) {
            throw opt.get();
        }
        return v;
    }

    public Optional<Exception> getException () {
        return opt;
    }

    public static <T> CheckedValue<T> returns (T t) {
        return new CheckedValue<T>(t);
    }

    public static <T> CheckedValue<T> rethrows (Exception e) {
        return new CheckedValue<T>(e);
    }

    public static <V> CheckedValue<V> from (CheckedValueSupplier<V> sup) {
        try {
            return CheckedValue.returns(sup.get());
        } catch (Exception e) {
            return Result.rethrows(e);
        }
    }

    public static <V> CheckedValue<V> escalates (CheckedValueSupplier<V> sup) {
        try {
            return CheckedValue.returns(sup.get());
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

}

ব্যবহার

//  Don't use this pattern with FileReader, it's meant to be an
//  example.  FileReader is a Closeable resource and as such should
//  be managed in a try-with-resources block or in another safe
//  manner that will make sure it is closed properly.

//  This will not compile as the FileReader constructor throws
//  an IOException.
    Function<String, FileReader> sToFr =
        (fn) -> new FileReader(Paths.get(fn).toFile());

// Alternative, this will compile.
    Function<String, CheckedValue<FileReader>> sToFr = (fn) -> {
        return CheckedValue.from (
            () -> new FileReader(Paths.get("/home/" + f).toFile()));
    };

// Single record usage
    // The call to get() will propagate the checked exception if it exists.
    FileReader readMe = pToFr.apply("/home/README").get();


// List of records usage
    List<String> paths = ...; //a list of paths to files
    Collection<CheckedValue<FileReader>> frs =
        paths.stream().map(pToFr).collect(Collectors.toList());

// Find out if creation of a file reader failed.
    boolean anyErrors = frs.stream()
        .filter(f -> f.getException().isPresent())
        .findAny().isPresent();

কি হচ্ছে?

একটি একক কার্যকরী ইন্টারফেস যা পরীক্ষিত ব্যতিক্রম ছুঁড়ে ফেলেছে তা তৈরি করা হয় ( CheckedValueSupplier)। এটি একমাত্র কার্যকরী ইন্টারফেস যা পরীক্ষিত ব্যতিক্রমগুলিকে মঞ্জুরি দেয়। অন্যান্য সমস্ত ক্রিয়ামূলক ইন্টারফেসগুলি CheckedValueSupplierএমন কোনও কোড মোড়ানোর জন্য উত্তোলন করবে যা একটি চেক করা ব্যতিক্রম ছুঁড়ে।

CheckedValueবর্গ কোনো যুক্তি করে একটি চেক করা ব্যতিক্রম ছোঁড়ার নির্বাহ ফল রাখা হবে। কোডটি এমন কোনও বিন্দুতে যে মানটিতে অ্যাক্সেসের চেষ্টা করে সেই বিন্দু না হওয়া পর্যন্ত এটি একটি পরীক্ষিত ব্যতিক্রমের প্রচারকে বাধা দেয় CheckedValue

এই পদ্ধতির সাথে সমস্যাগুলি।

  • আমরা এখন "ব্যতিক্রম" নিক্ষেপ করছি কার্যকরভাবে ছুঁড়ে দেওয়া নির্দিষ্ট ধরণেরটি কার্যকরভাবে লুকিয়ে।
  • আমরা অজানা যে CheckedValue#get()ডেকে আনা পর্যন্ত একটি ব্যতিক্রম ঘটেছে ।

গ্রাহক এবং অন্যান্য

কিছু কার্যকরী ইন্টারফেস (Consumer উদাহরণস্বরূপ) অবশ্যই কোনও ভিন্ন পদ্ধতিতে পরিচালনা করা উচিত কারণ তারা কোনও ফেরতের মান সরবরাহ করে না।

গ্রাহকের পরিবর্তে ফাংশন

একটি পদ্ধতি হ'ল গ্রাহকের পরিবর্তে কোনও ফাংশন ব্যবহার করা, যা স্ট্রিম পরিচালনা করার সময় প্রযোজ্য।

    List<String> lst = Lists.newArrayList();
// won't compile
lst.stream().forEach(e -> throwyMethod(e));
// compiles
lst.stream()
    .map(e -> CheckedValueSupplier.from(
        () -> {throwyMethod(e); return e;}))
    .filter(v -> v.getException().isPresent()); //this example may not actually run due to lazy stream behavior

ধাপে ধাপে বৃদ্ধি করা

বিকল্পভাবে, আপনি সর্বদা একটিতে আরোহণ করতে পারেন RuntimeException। অন্যান্য উত্তরগুলি রয়েছে যা এ এর ​​মধ্যে থেকে একটি চেক করা ব্যতিক্রমের ক্রমবৃদ্ধি coverেকে রাখেConsumer

গ্রাস করবেন না।

সমস্ত একসাথে কার্যকরী ইন্টারফেসগুলি এড়িয়ে চলুন এবং লুপের জন্য একটি ভাল-ওল-ফ্যাশনযুক্ত ব্যবহার করুন।


2

আমি একটি ওভারলোডেড ইউটিলিটি ফাংশন ব্যবহার করি unchecked()যা একাধিক ব্যবহারের ক্ষেত্রে পরিচালনা করে।


কিছু সাধারণ ব্যবহার

unchecked(() -> new File("hello.txt").createNewFile());

boolean fileWasCreated = unchecked(() -> new File("hello.txt").createNewFile());

myFiles.forEach(unchecked(file -> new File(file.path).createNewFile()));

সহায়তার সার্থকতা

public class UncheckedUtils {

    @FunctionalInterface
    public interface ThrowingConsumer<T> {
        void accept(T t) throws Exception;
    }

    @FunctionalInterface
    public interface ThrowingSupplier<T> {
        T get() throws Exception;
    }

    @FunctionalInterface
    public interface ThrowingRunnable {
        void run() throws Exception;
    }

    public static <T> Consumer<T> unchecked(
            ThrowingConsumer<T> throwingConsumer
    ) {
        return i -> {
            try {
                throwingConsumer.accept(i);
            } catch (Exception ex) {
                throw new RuntimeException(ex);
            }
        };
    }

    public static <T> T unchecked(
            ThrowingSupplier<T> throwingSupplier
    ) {
        try {
            return throwingSupplier.get();
        } catch (Exception ex) {
            throw new RuntimeException(ex);
        }
    }

    public static void unchecked(
            ThrowingRunnable throwing
    ) {
        try {
            throwing.run();
        } catch (Exception ex) {
            throw new RuntimeException(ex);
        }
    }
}

0

প্রস্তাবিত বেশিরভাগ সমাধান ই ছুঁড়ে ফেলেছে এমন ব্যতিক্রমটি প্রকারের জন্য সাধারণ বিতর্ক ব্যবহার করে।

এটি আরও একধাপ এগিয়ে নিয়ে যান এবং ব্যতিক্রম প্রকারের পরিবর্তে প্রবাহ ব্যতীত কোনও গ্রাহক হিসাবে পাস করুন, যেমন ...

Consumer<E extends Exception>

আপনি বেশ কয়েকটি পুনরায় ব্যবহারের যোগ্য বিভিন্নতা তৈরি করতে পারেন Consumer<Exception>যা আপনার অ্যাপ্লিকেশনটির সাধারণ ব্যতিক্রম হ্যান্ডলিংয়ের প্রয়োজনগুলিকে অন্তর্ভুক্ত করবে।


0

আমি জেনেরিক কিছু করব:

public interface Lambda {

    @FunctionalInterface
    public interface CheckedFunction<T> {

        T get() throws Exception;
    }

    public static <T> T handle(CheckedFunction<T> supplier) {
        try {
            return supplier.get();
        } catch (Exception exception) {
            throw new RuntimeException(exception);

        }
    }
}

ব্যবহার:

 Lambda.handle(() -> method());

0

ব্যবহার Jool Libraryবা jOOλ libraryথেকে বলুনJOOQ । এটি কেবল চেক করা ব্যতিক্রম হ্যান্ডেল করা ইন্টারফেস সরবরাহ করে না তবে সিক ক্লাসকে প্রচুর দরকারী পদ্ধতি সরবরাহ করে।

এছাড়াও, এতে 16 পরামিতি পর্যন্ত ফাংশনাল ইন্টারফেস রয়েছে। এছাড়াও, এটি টিপল ক্লাস সরবরাহ করে যা বিভিন্ন পরিস্থিতিতে ব্যবহৃত হয়।

জুল গিট লিংক

বিশেষত org.jooq.lambda.fi.util.functionপ্যাকেজটির জন্য লাইব্রেরি দেখার জন্য । এতে জাভা -8 থেকে চেকড প্রিপেন্ডযুক্ত সমস্ত ইন্টারফেস রয়েছে। রেফারেন্সের জন্য নীচে দেখুন: -

এখানে চিত্র বর্ণনা লিখুন


0

আমি কোনও জেনারিক যাদু নিয়ে যে কোনও জাভা ব্যাতিক্রমকে তাদের ধরার বা এগুলিতে আবৃত না করেইRuntimeException ফেলে দেওয়ার জন্য একটি ছোট্ট লিব এর লেখক ।

ব্যবহার: unchecked(() -> methodThrowingCheckedException())

public class UncheckedExceptions {

    /**
     * throws {@code exception} as unchecked exception, without wrapping exception.
     *
     * @return will never return anything, return type is set to {@code exception} only to be able to write <code>throw unchecked(exception)</code>
     * @throws T {@code exception} as unchecked exception
     */
    @SuppressWarnings("unchecked")
    public static <T extends Throwable> T unchecked(Exception exception) throws T {
        throw (T) exception;
    }


    @FunctionalInterface
    public interface UncheckedFunction<R> {
        R call() throws Exception;
    }

    /**
     * Executes given function,
     * catches and rethrows checked exceptions as unchecked exceptions, without wrapping exception.
     *
     * @return result of function
     * @see #unchecked(Exception)
     */
    public static <R> R unchecked(UncheckedFunction<R> function) {
        try {
            return function.call();
        } catch (Exception e) {
            throw unchecked(e);
        }
    }


    @FunctionalInterface
    public interface UncheckedMethod {
        void call() throws Exception;
    }

    /**
     * Executes given method,
     * catches and rethrows checked exceptions as unchecked exceptions, without wrapping exception.
     *
     * @see #unchecked(Exception)
     */
    public static void unchecked(UncheckedMethod method) {
        try {
            method.call();
        } catch (Exception e) {
            throw unchecked(e);
        }
    }
}

উত্স: https://github.com/qoomon/unchecked-exception-java


-7
public void frankTest() {
    int pageId= -1;

    List<Book> users= null;
    try {
        //Does Not Compile:  Object page=DatabaseConnection.getSpringConnection().queryForObject("SELECT * FROM bookmark_page", (rw, n) -> new Portal(rw.getInt("id"), "", users.parallelStream().filter(uu -> uu.getVbid() == rw.getString("user_id")).findFirst().get(), rw.getString("name")));

        //Compiles:
        Object page= DatabaseConnection.getSpringConnection().queryForObject("SELECT * FROM bookmark_page", (rw, n) -> { 
            try {
                final Book bk= users.stream().filter(bp -> { 
                    String name= null;
                    try {
                        name = rw.getString("name");
                    } catch (Exception e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    return bp.getTitle().equals(name); 
                }).limit(1).collect(Collectors.toList()).get(0);
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            return new Portal(rw.getInt("id"), "", users.get(0), rw.getString("name")); 
        } );
    } catch (Exception e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}

3
আপনার কাজ মন্তব্য করতে মন? কেবলমাত্র কোডের উত্তরগুলি এত কার্যকর নয়।
ফ্যান্টিম্যাক্সেক্স

@ ফ্র্যাঙ্কি আপনি <code>/<code>:) এর পরিবর্তে 4 স্পেসিং ব্যবহার করে আপনার উপস্থাপনাটি ঠিক করতে পারেন
অ্যাডরিয়ানখিস্বে
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.