Powszechnym sposobem na osiągnięcie tego celu jest użycie następnego kodu:

String url = "http://www.stackoverflow.com";
Intent i = new Intent(Intent.ACTION_VIEW);
i.setData(Uri.parse(url)); 
startActivity(i); 

Można to zmienić na krótką wersję kodu ...

Intent intent = new Intent(Intent.ACTION_VIEW).setData(Uri.parse("http://www.stackoverflow.com"));      
startActivity(intent); 

Lub:

Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse("http://www.stackoverflow.com")); 
startActivity(intent);

startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse("http://www.stackoverflow.com")));

Szczęśliwego kodowania!

Prosta Odpowiedź

Możesz zobaczyć oficjalną próbkę od dewelopera Androida.

/**
 * Open a web page of a specified URL
 *
 * @param url URL to open
 */
public void openWebPage(String url) {
    Uri webpage = Uri.parse(url);
    Intent intent = new Intent(Intent.ACTION_VIEW, webpage);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}

Jak to działa

Proszę spojrzeć na konstruktor Intent:

public Intent (String action, Uri uri)

Możesz przekazać instancję android.net.Uri do 2. parametru, a na podstawie podanego adresu URL zostanie utworzona nowa Intencja.

A następnie po prostu zadzwoń startActivity(Intent intent), aby rozpocząć nową aktywność, która jest powiązana z intencją z podanym adresem URL.

Czy muszę sprawdzić if oświadczenie?

Jeśli na urządzeniu nie ma aplikacji, które mogłyby otrzymać ukrytą intencję, aplikacja ulegnie awarii po wywołaniu funkcji startActivity (). Aby najpierw sprawdzić, czy aplikacja istnieje, aby otrzymać intencję, wywołaj resolveActivity () w obiekcie intencji. Jeśli wynik jest inny niż null, istnieje co najmniej jedna aplikacja, która może obsłużyć intencję i można bezpiecznie wywołać metodę startActivity(). Jeśli wynik jest null, nie należy używać intencji i, jeśli to możliwe, można powinien wyłączyć funkcję wywołującą intencję.

Bonus

Możesz pisać w jednej linii podczas tworzenia instancji Intent jak poniżej:

Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));

W 2.3 miałem więcej szczęścia z

final Intent intent = new Intent(Intent.ACTION_VIEW).setData(Uri.parse(url));
activity.startActivity(intent);

Różnica polega na użyciu Intent.ACTION_VIEW zamiast ciągu "android.intent.action.VIEW"

Spróbuj tego:

Uri uri = Uri.parse("https://www.google.com");
startActivity(new Intent(Intent.ACTION_VIEW, uri));

Lub jeśli chcesz, aby przeglądarka internetowa otworzyła się w Twojej aktywności, zrób tak:

WebView webView = (WebView) findViewById(R.id.webView1);
WebSettings settings = webview.getSettings();
settings.setJavaScriptEnabled(true);
webView.loadUrl(URL);

I jeśli chcesz użyć sterowania zoomem w swojej przeglądarce, możesz użyć:

settings.setSupportZoom(true);
settings.setBuiltInZoomControls(true);

Jeśli chcesz pokazać użytkownikowi dialog z całą listą przeglądarek, aby mógł wybrać preferowany, oto przykładowy kod:

private static final String HTTPS = "https://";
private static final String HTTP = "http://";

public static void openBrowser(final Context context, String url) {

     if (!url.startsWith(HTTP) && !url.startsWith(HTTPS)) {
            url = HTTP + url;
     }

     Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
     context.startActivity(Intent.createChooser(intent, "Choose browser"));// Choose browser is arbitrary :)

}

Tak jak inne rozwiązania napisali (że działa dobrze), chciałbym odpowiedzieć na to samo, ale z końcówką, że myślę, że większość wolałaby użyć.

Jeśli chcesz, aby aplikacja zaczęła się otwierać w nowym zadaniu, niezależnie od siebie, zamiast pozostać na tym samym stosie, możesz użyć tego kodu:

final Intent intent=new Intent(Intent.ACTION_VIEW,Uri.parse(url));
intent.addFlags(Intent.FLAG_ACTIVITY_NO_HISTORY|Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET|Intent.FLAG_ACTIVITY_NEW_TASK|Intent.FLAG_ACTIVITY_MULTIPLE_TASK);
startActivity(intent);

Istnieje również sposób otwarcia adresu URL w Chrome Custom Tabs . Przykład w Kotlinie:

@JvmStatic
fun openWebsite(activity: Activity, websiteUrl: String, useWebBrowserAppAsFallbackIfPossible: Boolean) {
    var websiteUrl = websiteUrl
    if (TextUtils.isEmpty(websiteUrl))
        return
    if (websiteUrl.startsWith("www"))
        websiteUrl = "http://$websiteUrl"
    else if (!websiteUrl.startsWith("http"))
        websiteUrl = "http://www.$websiteUrl"
    val finalWebsiteUrl = websiteUrl
    //https://github.com/GoogleChrome/custom-tabs-client
    val webviewFallback = object : CustomTabActivityHelper.CustomTabFallback {
        override fun openUri(activity: Activity, uri: Uri?) {
            var intent: Intent
            if (useWebBrowserAppAsFallbackIfPossible) {
                intent = Intent(Intent.ACTION_VIEW, Uri.parse(finalWebsiteUrl))
                intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_NO_HISTORY
                        or Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET or Intent.FLAG_ACTIVITY_MULTIPLE_TASK)
                if (!CollectionUtil.isEmpty(activity.packageManager.queryIntentActivities(intent, 0))) {
                    activity.startActivity(intent)
                    return
                }
            }
            // open our own Activity to show the URL
            intent = Intent(activity, WebViewActivity::class.java)
            WebViewActivity.prepareIntent(intent, finalWebsiteUrl)
            activity.startActivity(intent)
        }
    }
    val uri = Uri.parse(finalWebsiteUrl)
    val intentBuilder = CustomTabsIntent.Builder()
    val customTabsIntent = intentBuilder.build()
    customTabsIntent.intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_NO_HISTORY
            or Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET or Intent.FLAG_ACTIVITY_MULTIPLE_TASK)
    CustomTabActivityHelper.openCustomTab(activity, customTabsIntent, uri, webviewFallback)
}

Inna opcja w załaduj adres Url w tej samej aplikacji przy użyciu Webview

webView = (WebView) findViewById(R.id.webView1);
webView.getSettings().setJavaScriptEnabled(true);
webView.loadUrl("http://www.google.com");

Możesz też iść tą drogą

W xml:

<?xml version="1.0" encoding="utf-8"?>
<WebView  
xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/webView1"
android:layout_width="fill_parent"
android:layout_height="fill_parent" />

W kodzie Javy:

public class WebViewActivity extends Activity {

private WebView webView;

public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.webview);

    webView = (WebView) findViewById(R.id.webView1);
    webView.getSettings().setJavaScriptEnabled(true);
    webView.loadUrl("http://www.google.com");

 }

}

W manifeście nie zapomnij dodać uprawnień internetowych...

Webview może być używany do ładowania adresu Url w aplikacji. Adres URL może być dostarczony przez użytkownika w widoku tekstowym lub można go kodować na twardo.

Nie zapomnij również o uprawnieniach internetowych w AndroidManifest.

String url="http://developer.android.com/index.html"

WebView wv=(WebView)findViewById(R.id.webView);
wv.setWebViewClient(new MyBrowser());
wv.getSettings().setLoadsImagesAutomatically(true);
wv.getSettings().setJavaScriptEnabled(true);
wv.setScrollBarStyle(View.SCROLLBARS_INSIDE_OVERLAY);
wv.loadUrl(url);

private class MyBrowser extends WebViewClient {
    @Override
    public boolean shouldOverrideUrlLoading(WebView view, String url) {
        view.loadUrl(url);
        return true;
    }
}

Wewnątrz w bloku try wklej poniższy kod,Android Intent używa bezpośrednio łącza w szelkach URI (Uniform Resource Identifier) w celu zidentyfikowania lokalizacji łącza.

Możesz spróbować tego:

Intent myIntent = new Intent(Intent.ACTION_VIEW, Uri.parse("http://www.google.com"));
startActivity(myIntent);

Odpowiedź Kotlina:

val browserIntent = Intent(Intent.ACTION_VIEW, uri)
ContextCompat.startActivity(context, browserIntent, null)

Dodałem rozszerzenie na Uri aby to jeszcze ułatwić

myUri.openInBrowser(context)

fun Uri?.openInBrowser(context: Context) {
    this ?: return // Do nothing if uri is null

    val browserIntent = Intent(Intent.ACTION_VIEW, this)
    ContextCompat.startActivity(context, browserIntent, null)
}

Jako bonus, oto prosta funkcja rozszerzenia, aby bezpiecznie przekonwertować ciąg znaków na Uri.

"https://stackoverflow.com".asUri()?.openInBrowser(context)

fun String?.asUri(): Uri? {
    try {
        return Uri.parse(this)
    } catch (e: Exception) {}
    return null
}

Krótka wersja kodu...

 if (!strUrl.startsWith("http://") && !strUrl.startsWith("https://")){
     strUrl= "http://" + strUrl;
 }


 startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse(strUrl)));

Proste i najlepsze praktyki

Metoda 1:

String intentUrl="www.google.com";
Intent webIntent = new Intent(Intent.ACTION_VIEW, Uri.parse(intentUrl));
    if(webIntent.resolveActivity(getPackageManager())!=null){
        startActivity(webIntent);    
    }else{
      /*show Error Toast 
              or 
        Open play store to download browser*/
            }

Metoda 2:

try{
    String intentUrl="www.google.com";
    Intent webIntent = new Intent(Intent.ACTION_VIEW, Uri.parse(intentUrl));
        startActivity(webIntent);
    }catch (ActivityNotFoundException e){
                /*show Error Toast
                        or
                  Open play store to download browser*/
    }

String url = "http://www.example.com";
Intent i = new Intent(Intent.ACTION_VIEW);
i.setData(Uri.parse(url));
startActivity(i);

Intent getWebPage = new Intent(Intent.ACTION_VIEW, Uri.parse(MyLink));          
startActivity(getWebPage);

ODPOWIEDŹ MarkB jest słuszna. W moim przypadku używam Xamarin, a kod do użycia z C# i Xamarin to:

var uri = Android.Net.Uri.Parse ("http://www.xamarin.com");
var intent = new Intent (Intent.ActionView, uri);
StartActivity (intent);

Ta informacja pochodzi z: https://developer.xamarin.com/recipes/android/fundamentals/intent/open_a_webpage_in_the_browser_application/

Chrome custom tabs są teraz dostępne:

Pierwszym krokiem jest dodanie biblioteki obsługi niestandardowych kart do Twojej kompilacji.plik gradle:

dependencies {
    ...
    compile 'com.android.support:customtabs:24.2.0'
}

A następnie, aby otworzyć niestandardową kartę chrome:

String url = "https://www.google.pt/";
CustomTabsIntent.Builder builder = new CustomTabsIntent.Builder();
CustomTabsIntent customTabsIntent = builder.build();
customTabsIntent.launchUrl(this, Uri.parse(url));

Aby uzyskać więcej informacji: https://developer.chrome.com/multidevice/android/customtabs

Prosty, widok strony przez intent,

Intent viewIntent = new Intent("android.intent.action.VIEW", Uri.parse("http://www.yoursite.in"));
startActivity(viewIntent);  

Użyj tego prostego kodu, aby wyświetlić swoją stronę w aplikacji na Androida.

Dodaj uprawnienia internetowe w pliku manifestu,

<uses-permission android:name="android.permission.INTERNET" /> 

Więc Szukałem tego przez długi czas, ponieważ wszystkie inne odpowiedzi otwierały domyślną aplikację dla tego linku, ale nie domyślna przeglądarka i tego chciałem.

W końcu udało mi się to zrobić:

// gathering the default browser
final Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse("http://"));
final ResolveInfo resolveInfo = context.getPackageManager()
    .resolveActivity(intent, PackageManager.MATCH_DEFAULT_ONLY);
String defaultBrowserPackageName = resolveInfo.activityInfo.packageName;


final Intent intent2 = new Intent(Intent.ACTION_VIEW);
intent2.setData(Uri.parse(url));

if (!defaultBrowserPackageName.equals("android") {
    // android = no default browser is set 
    // (android < 6 or fresh browser install or simply no default set)
    // if it's the case (not in this block), it will just use normal way.
    intent2.setPackage(defaultBrowserPackageName);
}

context.startActivity(intent2);

BTW, można zauważyć context.cokolwiek, ponieważ użyłem tego do statycznej metody util, jeśli robisz to w działaniu, nie jest to potrzebne.

Na podstawie odpowiedzi Marka B i komentarzy poniżej:

protected void launchUrl(String url) {
    Uri uri = Uri.parse(url);

    if (uri.getScheme() == null || uri.getScheme().isEmpty()) {
        uri = Uri.parse("http://" + url);
    }

    Intent browserIntent = new Intent(Intent.ACTION_VIEW, uri);

    if (browserIntent.resolveActivity(getPackageManager()) != null) {
        startActivity(browserIntent);
    }
}

android.webkit.URLUtil ma metodę guessUrl(String) działa doskonale (nawet z file:// lub data://) od Api level 1 (Android 1.0). Użyj jako:

String url = URLUtil.guessUrl(link);

// url.com            ->  http://url.com/     (adds http://)
// http://url         ->  http://url.com/     (adds .com)
// https://url        ->  https://url.com/    (adds .com)
// url                ->  http://www.url.com/ (adds http://www. and .com)
// http://www.url.com ->  http://www.url.com/ 
// https://url.com    ->  https://url.com/
// file://dir/to/file ->  file://dir/to/file
// data://dataline    ->  data://dataline
// content://test     ->  content://test

W wywołaniu aktywności:

Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(URLUtil.guessUrl(download_link)));

if (intent.resolveActivity(getPackageManager()) != null)
    startActivity(intent);

Sprawdź całość guessUrl kod aby uzyskać więcej informacji.

Dobra, sprawdziłem każdą odpowiedź, ale jaka aplikacja ma deeplinking z tym samym adresem URL, którego użytkownik chce użyć?

Dzisiaj dostałem tę sprawę i odpowiedź brzmi browserIntent.setPackage("browser_package_name");

Np.:

   Intent browserIntent = new Intent(Intent.ACTION_VIEW, Uri.parse("http://www.google.com"));
    browserIntent.setPackage("com.android.chrome"); // Whatever browser you are using
    startActivity(browserIntent);

Wystarczy użyć krótkiego, aby otworzyć adres Url w przeglądarce:

Intent browserIntent = new Intent(Intent.ACTION_VIEW, Uri.parse("YourUrlHere"));
startActivity(browserIntent);

String url = "https://www.thandroid-mania.com/";
if (url.startsWith("https://") || url.startsWith("http://")) {
    Uri uri = Uri.parse(url);
    Intent intent = new Intent(Intent.ACTION_VIEW, uri);
    startActivity(intent);
}else{
    Toast.makeText(mContext, "Invalid Url", Toast.LENGTH_SHORT).show();
}

Ten błąd wystąpił z powodu nieprawidłowego adresu URL, System Operacyjny Android nie może znaleźć widoku akcji dla Twoich danych. Musisz więc zweryfikować, czy adres URL jest poprawny, czy nie.

Myślę, że to jest najlepsze

openBrowser(context, "http://www.google.com")

Wstaw poniższy kod do klasy globalnej

    public static void openBrowser(Context context, String url) {

        if (!url.startsWith("http://") && !url.startsWith("https://"))
            url = "http://" + url;

        Intent browserIntent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
        context.startActivity(browserIntent);
    }

Ten sposób używa metody, aby umożliwić wprowadzanie dowolnego ciągu znaków zamiast stałego wejścia. Zapisuje to niektóre linie kodu, jeśli są używane wielokrotnie, ponieważ do wywołania metody potrzebne są tylko trzy linie.

public Intent getWebIntent(String url) {
    //Make sure it is a valid URL before parsing the URL.
    if(!url.contains("http://") && !url.contains("https://")){
        //If it isn't, just add the HTTP protocol at the start of the URL.
        url = "http://" + url;
    }
    //create the intent
    Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(url)/*And parse the valid URL. It doesn't need to be changed at this point, it we don't create an instance for it*/);
    if (intent.resolveActivity(getPackageManager()) != null) {
        //Make sure there is an app to handle this intent
        return intent;
    }
    //If there is no app, return null.
    return null;
}

Użycie tej metody sprawia, że jest ona uniwersalna. Nie musi być umieszczony w konkretnym ćwiczeniu, ponieważ można go używać w następujący sposób:

Intent i = getWebIntent("google.com");
if(i != null)
    startActivity();

Lub jeśli chcesz rozpocząć działanie poza aktywnością, po prostu wywołaj startActivity na aktywności instancja:

Intent i = getWebIntent("google.com");
if(i != null)
    activityInstance.startActivity(i);

Jak widać w obu tych blokach kodu jest null-check. Jest tak, ponieważ zwraca null, jeśli nie ma aplikacji do obsługi intencji.

Ta metoda domyślnie jest ustawiona na HTTP, jeśli nie ma zdefiniowanego protokołu, ponieważ istnieją strony internetowe, które nie mają certyfikatu SSL (czego potrzebujesz do połączenia HTTPS), a te przestaną działać, jeśli spróbujesz użyć HTTPS i go nie ma. Każda witryna może nadal wymuszać https, więc te strony lądują na HTTPS albo sposób

Ponieważ ta metoda wykorzystuje zewnętrzne zasoby do wyświetlania strony, nie ma potrzeby deklarowania uprawnień internetowych. Aplikacja, która wyświetla stronę internetową, musi to zrobić

/ / Onclick Listener

  @Override
      public void onClick(View v) {
        String webUrl = news.getNewsURL();
        if(webUrl!="")
        Utils.intentWebURL(mContext, webUrl);
      }

//Twoja Metoda Util

public static void intentWebURL(Context context, String url) {
        if (!url.startsWith("http://") && !url.startsWith("https://")) {
            url = "http://" + url;
        }
        boolean flag = isURL(url);
        if (flag) {
            Intent browserIntent = new Intent(Intent.ACTION_VIEW,
                    Uri.parse(url));
            context.startActivity(browserIntent);
        }

    }

Kotlin

startActivity(Intent(Intent.ACTION_VIEW).apply {
            data = Uri.parse(your_link)
        })

Z Anko metoda biblioteczna

fun Context.browse(url: String, newTask: Boolean = false): Boolean {
    try {
        val intent = Intent(Intent.ACTION_VIEW)
        intent.data = Uri.parse(url)
        if (newTask) {
            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
        }
        startActivity(intent)
        return true
    } catch (e: ActivityNotFoundException) {
        e.printStackTrace()
        return false
    }
}